Teste a tradução automática

Nesta página, mostramos um exemplo de como usar a API Vertex AI para traduzir texto de um idioma para outro.

Neste exemplo, você implanta as cargas de trabalho sem usar GPUs. Para fazer a implantação usando GPUs, siga as etapas em Implantar cargas de trabalho de contêineres 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 Usar a Vertex AI.

  2. Configure a API Python Vertex AI seguindo as instruções no Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Python da Vertex AI.

  3. Crie um arquivo Python main.py. Esse script usa a API Translation Google Cloud, acessada com um endpoint de contêiner, para fazer 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. Crie 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 com uma identidade de usuário. Verifique se você definiu 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 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 implantada.

      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 vai 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