Prova la traduzione automatica

L'API Cloud Translation ti consente di tradurre dinamicamente il testo da una lingua all'altra. In questo tutorial, eseguirai il deployment di un servizio di traduzione containerizzato in Google Distributed Cloud (GDC) Sandbox senza GPU.

Per eseguire workload con accelerazione GPU, consulta Esegui il deployment dei workload dei container GPU.

API Translation

L'esempio seguente mostra l'utilizzo di Vertex AI per la traduzione di testo.

  1. Assicurati di configurare l'accesso a Vertex AI come descritto in Utilizzo di Vertex AI.

  2. Configura l'API Vertex AI Python seguendo le istruzioni riportate nella guida rapida di Vertex AI utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Vertex AI Python.

  3. Crea un file Python main.py. Questo script utilizza l'API Translation Google Cloud, a cui si accede tramite un endpoint del container, per eseguire le traduzioni.

    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)

  4. Crea un file Docker contenente lo script Python:

    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"]

  5. Crea l'immagine Docker per l'applicazione di traduzione:

    docker build -t translation-app .

  6. Segui le istruzioni riportate in Configura Docker per:

    1. Configura Docker,
    2. Crea un secret
    3. Carica l'immagine su HaaS (Harbor as a Service).

  7. Accedi al cluster utente e genera il relativo file kubeconfig con un'identità utente. Assicurati di impostare il percorso kubeconfig come variabile di ambiente:

    export KUBECONFIG=${CLUSTER_KUBECONFIG_PATH}

  8. Crea ed esegui il deployment delle risorse personalizzate Deployment e Service di Kubernetes. Per abilitare il traffico in uscita del container, assicurati di includere l'etichetta egress.networking.gke.io/enabled: "true", come mostrato in questo esempio.

    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

    Sostituisci quanto segue:

    • HARBOR_INSTANCE_URL: l'URL dell'istanza Harbor.
    • HARBOR_PROJECT: il progetto Harbor.
    • SECRET: il nome del secret creato per archiviare le credenziali Docker.

  9. Verifica che i pod siano stati creati dal deployment:

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

  10. Crea una policy di rete per consentire tutto il traffico di rete verso il progetto tenant:

    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

  11. Esporta l'indirizzo IP per il servizio:

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

  12. Crea una sessione del tunnel SSH per il workload di cui hai eseguito il deployment.

      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

  13. Testa il servizio inviando un payload JSON con il testo e la lingua di destinazione a http://${IP}:8080/translate, utilizzando una richiesta POST con l'intestazione Content-Type impostata su application/json. Il seguente comando curl tradurrà "Hello, world!" in spagnolo (es):

    curl -X POST -H "Content-Type: application/json" -d '{"text": "Hello, world\\!", "target\_language": "es"}' http://${IP}:8080/translate