Prova la traduzione automatica

Questa pagina descrive un esempio di utilizzo dell'API Vertex AI per tradurre il testo da una lingua a un'altra.

In questo esempio, esegui il deployment dei carichi di lavoro senza utilizzare le GPU. Per eseguire il deployment utilizzando le GPU, segui i passaggi descritti in Esegui il deployment dei carichi di lavoro 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 che utilizza le librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Python di Vertex AI.

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

    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 e
    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 e implementa le risorse personalizzate di deployment e servizio Kubernetes. Per attivare l'uscita del contenitore, 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 al 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 che hai 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