Diese Seite wurde von der Cloud Translation API übersetzt.

Maschinelle Übersetzung ausprobieren

Auf dieser Seite wird ein Beispiel für die Verwendung der Vertex AI API zum Übersetzen von Text aus einer Sprache in eine andere beschrieben.

In diesem Beispiel stellen Sie die Arbeitslasten ohne GPUs bereit. Wenn Sie GPUs für die Bereitstellung verwenden möchten, folgen Sie der Anleitung unter GPU-Containerarbeitslasten bereitstellen.

Translation API

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

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

Erstellen Sie eine Python-Datei mit dem Namen main.py. In diesem Skript wird die Google CloudTranslation API verwendet, auf die über einen Containerendpunkt zugegriffen wird, um Übersetzungen auszufü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. Docker konfigurieren
2. Erstellen Sie ein Secret und
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. Achten Sie darauf, dass Sie den kubeconfig-Pfad als Umgebungsvariable festlegen:
```
export KUBECONFIG=${CLUSTER_KUBECONFIG_PATH}
```

Erstellen und stellen Sie die benutzerdefinierten Kubernetes-Deployment- und -Dienstressourcen bereit. Wenn Sie den Containerausgang aktivieren möchten, müssen Sie das Label egress.networking.gke.io/enabled: "true" wie in diesem Beispiel angeben.

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 von der Bereitstellung erstellt wurden:

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

Erstellen Sie eine Netzwerkrichtlinie, um den gesamten Netzwerk-Traffic 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