Esta página foi traduzida pela API Cloud Translation.

Teste a tradução automática

Esta página mostra um exemplo de uso da 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.

Configure o acesso à Vertex AI conforme descrito em Usar a Vertex AI.
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.

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)

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

Crie a imagem do Docker para o aplicativo de tradução:
```
docker build -t translation-app .
```
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).
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}
```

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.

Verifique se os pods foram criados pela implantação:

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

Crie uma política de rede para permitir todo o tráfego de rede para o projeto do 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

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}'`

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

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

Teste a tradução automática Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

API Translation

Teste a tradução automática