Essayer la traduction automatique

Cette page présente un exemple d'utilisation de l'API Vertex AI pour traduire du texte d'une langue à une autre.

Dans cet exemple, vous déployez les charges de travail sans utiliser de GPU. Pour effectuer un déploiement à l'aide de GPU, suivez les étapes décrites dans Déployer des charges de travail de conteneur GPU.

API Translation

L'exemple suivant montre comment utiliser Vertex AI pour la traduction de texte.

  1. Assurez-vous de configurer l'accès à Vertex AI comme décrit dans Utiliser Vertex AI.
  2. Configurez l'API Python Vertex AI en suivant les instructions du guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI en langage Python.

  3. Créez un fichier Python main.py. Ce script utilise l'API Translation Google Cloud, accessible à l'aide d'un point de terminaison de conteneur, pour effectuer des traductions.

    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. Créez un fichier Docker contenant le 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. Créez l'image Docker pour l'application de traduction :

    docker build -t translation-app .
    
  6. Suivez les instructions de la section Configurer Docker pour :

    1. Configurez Docker.
    2. créer un secret ;
    3. Importez l'image dans HaaS (Harbor as a Service).
  7. Connectez-vous au cluster d'utilisateur et générez son fichier kubeconfig avec une identité utilisateur. Assurez-vous de définir le chemin d'accès kubeconfig en tant que variable d'environnement :

    export KUBECONFIG=${CLUSTER_KUBECONFIG_PATH}
    
  8. Créez et déployez les ressources personnalisées de déploiement et de service Kubernetes. Pour activer la sortie de conteneur, veillez à inclure le libellé egress.networking.gke.io/enabled: "true", comme indiqué dans cet exemple.

    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
    

    Remplacez les éléments suivants :

    • HARBOR_INSTANCE_URL : URL de l'instance Harbor.
    • HARBOR_PROJECT : projet Harbor.
    • SECRET : nom du secret créé pour stocker les identifiants Docker.
  9. Vérifiez que les pods ont été créés par le déploiement :

    kubectl --kubeconfig ${KUBECONFIG} get pods -n TENANT_PROJECT
    
  10. Créez une règle de réseau pour autoriser tout le trafic réseau vers le projet locataire :

    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. Exportez l'adresse IP du service :

    export IP=`kubectl --kubeconfig=${KUBECONFIG} get service nginx-service \
          -n TENANT_PROJECT -o jsonpath='{.status.loadBalancer.ingress[*].ip}'`
    
  12. Créez une session de tunnel SSH vers la charge de travail que vous avez déployée.

      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. Testez le service en envoyant une charge utile JSON avec le texte et la langue cible à http://${IP}:8080/translate, à l'aide d'une requête POST avec l'en-tête Content-Type défini sur application/json. La commande curl suivante traduira "Hello, world!" en espagnol (es) :

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