Teste a tradução automática

A API Cloud Translation permite traduzir textos de maneira dinâmica entre idiomas. Neste tutorial, você vai implantar um serviço de tradução conteinerizado no sandbox do Google Distributed Cloud (GDC) sem GPUs.

Para executar cargas de trabalho aceleradas por GPU, consulte Implantar cargas de trabalho de contêiner de GPU.

API Translation

O exemplo a seguir demonstra o uso da Vertex AI para tradução de texto.

  1. Configure o acesso à Vertex AI conforme descrito em Como usar a Vertex AI.
  2. Configure a API Vertex AI para Python seguindo as instruções no guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Python do Vertex AI.

  3. Crie um arquivo Python main.py. Esse script usa a Google Cloud API Translation, acessada por um endpoint de contêiner, para realizar traduções.

    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. Crie um arquivo Docker que contenha o 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. Crie a imagem Docker para o aplicativo de tradução:

    docker build -t translation-app .
    
  6. Siga as instruções em Configurar o Docker para:

    1. Configure o Docker.
    2. Criar um secret e
    3. Faça upload da imagem para o HaaS (Harbor como serviço).
  7. Faça login no cluster de usuário e gere o arquivo kubeconfig dele com uma identidade de usuário. Defina o caminho do kubeconfig como uma variável de ambiente:

    export KUBECONFIG=${CLUSTER_KUBECONFIG_PATH}
    
  8. Crie e implante os recursos personalizados de implantação e serviço do Kubernetes. Para ativar a saída do contêiner, inclua o rótulo egress.networking.gke.io/enabled: "true", conforme mostrado neste exemplo.

    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
    

    Substitua:

    • HARBOR_INSTANCE_URL: o URL da instância do Harbor.
    • HARBOR_PROJECT: o projeto do Harbor.
    • SECRET: o nome do secret criado para armazenar as credenciais do Docker.
  9. Verifique se os pods foram criados pela implantação:

    kubectl --kubeconfig ${KUBECONFIG} get pods -n TENANT_PROJECT
    
  10. Crie uma política de rede para permitir todo o tráfego de rede para o projeto de locatário:

    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. Exporte o endereço IP do serviço:

    export IP=`kubectl --kubeconfig=${KUBECONFIG} get service nginx-service \
          -n TENANT_PROJECT -o jsonpath='{.status.loadBalancer.ingress[*].ip}'`
    
  12. Crie uma sessão de túnel SSH para a carga de trabalho que você implantou.

      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. Teste o serviço enviando um payload JSON com o texto e o idioma de destino para http://${IP}:8080/translate, usando uma solicitação POST com o cabeçalho Content-Type definido como application/json. O comando curl a seguir traduzirá "Hello, world!" para espanhol (es):

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