Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Maschinelle Übersetzung ausprobieren

Mit der Cloud Translation API können Sie Text dynamisch zwischen Sprachen übersetzen. In dieser Anleitung stellen Sie einen containerisierten Übersetzungsdienst in der Google Distributed Cloud (GDC) Sandbox ohne GPUs bereit.

Informationen zum Ausführen von GPU-beschleunigten Arbeitslasten finden Sie unter GPU-Containerarbeitslasten bereitstellen.

Translation API

Im folgenden Beispiel wird die Verwendung von Vertex AI für die Textübersetzung veranschaulicht.

Richten Sie den Zugriff auf Vertex AI wie unter Vertex AI verwenden beschrieben ein.
Richten Sie die Python Vertex AI API ein. Folgen Sie dazu der Anleitung in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Python API.

Erstellen Sie eine Python-Datei main.py. Dieses Script nutzt die Google CloudTranslation API, auf die über einen Containerendpunkt zugegriffen wird, um Übersetzungen durchzuführen.

import os
import requests # Use requests for HTTP calls
from flask import Flask, request, jsonify

app = Flask(__name__)

TRANSLATE_API_URL = 'https://translation.googleapis.com/language/translate/v2'

@app.route('/translate', methods=['POST'])
def translate_text():

    try:
        data = request.get_json()
        text_to_translate = data.get('text')
        target_language = data.get('target_language', 'en') # Default to English

        if not text_to_translate:
            return jsonify({'error': 'Missing "text" in request body'}), 400

        params = {
            'key': '${API_KEY}', // insert API key
            'q': text_to_translate,
            'target': target_language
        }

        response = requests.post(TRANSLATE_API_URL, params=params)
        response.raise_for_status() # Raise an exception for bad status codes (4xx or 5xx)

        result = response.json()

        # The structure of the response from the REST API is slightly different
        # It's usually: {'data': {'translations': [{'translatedText': '...', 'detectedSourceLanguage': '...'}]}}
        if 'data' in result and 'translations' in result['data'] and len(result['data']['translations']) > 0:
            translation_info = result['data']['translations'][0]
            return jsonify({
                'original_text': text_to_translate,
                'translated_text': translation_info['translatedText'],
                'detected_source_language': translation_info.get('detectedSourceLanguage')
            })
        else:
            return jsonify({'error': 'Unexpected response format from Translation API', 'details': result}), 500

    except requests.exceptions.HTTPError as http_err:
        print(f"HTTP error occurred: {http_err} - {response.text}")
        return jsonify({'error': f"Translation API request failed: {http_err}", 'details': response.text}), response.status_code
    except Exception as e:
        print(f"Error during translation: {e}")
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    port = int(os.environ.get('PORT', 8080))
    app.run(debug=True, host='0.0.0.0', port=port)

Erstellen Sie eine Docker-Datei, die das Python-Skript enthält:

FROM python:3.9-slim

WORKDIR /app

COPY . /app

RUN pip install --no-cache-dir -r requirements.txt

EXPOSE 8080
ENV PORT 8080

CMD ["python", "main.py"]

Erstellen Sie das Docker-Image für die Übersetzungsanwendung:
```
docker build -t translation-app .
```
Folgen Sie der Anleitung unter Docker konfigurieren, um:
1. Konfigurieren Sie Docker,
2. Secret erstellen
3. Laden Sie das Image in HaaS (Harbor as a Service) hoch.
Melden Sie sich im Nutzercluster an und generieren Sie die kubeconfig-Datei mit einer Nutzeridentität. Legen Sie den kubeconfig-Pfad als Umgebungsvariable fest:
```
export KUBECONFIG=${CLUSTER_KUBECONFIG_PATH}
```

Erstellen Sie die benutzerdefinierten Ressourcen für das Kubernetes-Deployment und den Kubernetes-Dienst und stellen Sie sie bereit. Wenn Sie ausgehenden Container-Traffic aktivieren möchten, müssen Sie das Label egress.networking.gke.io/enabled: "true" einfügen, wie in diesem Beispiel gezeigt.

kubectl --kubeconfig ${KUBECONFIG} -n TENANT_PROJECT \
create -f - <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: translation-deployment-apikey
spec:
  replicas: 2
  selector:
    matchLabels:
      app: translation-apikey
  template:
    metadata:
      labels:
        app: translation-apikey
        egress.networking.gke.io/enabled: "true"
    spec:
      dnsConfig:
        nameservers:
        - 8.8.8.8
      containers:
      - name: translation-app
        image: HARBOR_INSTANCE_URL/HARBOR_PROJECT/translation-app:latest
        ports:
        - containerPort: 8080
      imagePullSecrets:
        - name: SECRET

---
apiVersion: v1
kind: Service
metadata:
  name: translation-service-apikey
spec:
  type: LoadBalancer
  selector:
    app: translation-apikey
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080
EOF

Ersetzen Sie Folgendes:

HARBOR_INSTANCE_URL: die URL der Harbor-Instanz.
HARBOR_PROJECT: das Harbor-Projekt.
SECRET: Der Name des Secrets, das zum Speichern von Docker-Anmeldedaten erstellt wurde.

Prüfen Sie, ob die Pods durch das Deployment erstellt wurden:

kubectl --kubeconfig ${KUBECONFIG} get pods -n TENANT_PROJECT

Erstellen Sie eine Netzwerkrichtlinie, um den gesamten Netzwerkverkehr zum Mandantenprojekt zuzulassen:

kubectl --kubeconfig ${KUBECONFIG} -n TENANT_PROJECT \
create -f - <<EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  annotations:
  name: allow-all
spec:
  ingress:
  - from:
    - ipBlock:
        cidr: 0.0.0.0/0
  podSelector: {}
  policyTypes:
  - Ingress
EOF

Exportieren Sie die IP-Adresse für den Dienst:

export IP=`kubectl --kubeconfig=${KUBECONFIG} get service nginx-service \
      -n TENANT_PROJECT -o jsonpath='{.status.loadBalancer.ingress[*].ip}'`

Erstellen Sie eine SSH-Tunnelsitzung für die bereitgestellte Arbeitslast.

  sshuttle -r zone1-org-1-data@GDC_SANDBOX_INSTANCE_NAME --no-latency-control \
  --ssh-cmd 'gcloud compute ssh --project PROJECT_NAME --zone ZONE --tunnel-through-iap' \
  10.200.0.0/16 --dns

Testen Sie den Dienst, indem Sie eine JSON-Nutzlast mit dem Text und der Zielsprache an http://${IP}:8080/translate senden. Verwenden Sie dazu eine POST-Anfrage, bei der der Header Content-Type auf application/json gesetzt ist. Mit dem folgenden curl-Befehl wird „Hello, world!“ ins Spanische (es) übersetzt:
```
curl -X POST -H "Content-Type: application/json" -d '{"text": "Hello, world\\!", "target\_language": "es"}' http://${IP}:8080/translate
```

Maschinelle Übersetzung ausprobieren Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Translation API

Maschinelle Übersetzung ausprobieren