Esta página foi traduzida pela API Cloud Translation.

Experimente a tradução automática

Esta página explica um exemplo de utilização da API Vertex AI para traduzir texto de um idioma para outro.

Neste exemplo, implementa as cargas de trabalho sem usar GPUs. Para implementar usando GPUs, siga os passos em Implemente cargas de trabalho de contentores de GPU.

Translation API

O exemplo seguinte demonstra a utilização do Vertex AI para a tradução de texto.

Certifique-se de que configura o acesso ao Vertex AI conforme descrito no artigo Usar o Vertex AI.
Configure a API Vertex AI Python seguindo as instruções no guia de início rápido do Vertex AI com bibliotecas cliente. Para mais informações, consulte a documentação de referência da API Python do Vertex AI.

Crie um ficheiro Python main.py. Este script tira partido da Google Cloud API Translation, acedida através de um ponto final do contentor, 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 ficheiro 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 a aplicação de tradução:
```
docker build -t translation-app .
```
Siga as instruções em Configurar o Docker para:
1. Configure o Docker,
2. Crie um segredo e
3. Carregue a imagem para o HaaS (Harbor as a Service).
Inicie sessão no cluster de utilizadores e gere o respetivo ficheiro kubeconfig com uma identidade de utilizador. Certifique-se de que define o caminho do kubeconfig como uma variável de ambiente:
```
export KUBECONFIG=${CLUSTER_KUBECONFIG_PATH}
```

Crie e implemente os recursos personalizados de implementação e serviço do Kubernetes. Para ativar a saída do contentor, certifique-se de que inclui a etiqueta 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 o seguinte:

HARBOR_INSTANCE_URL: o URL da instância do Harbor.
HARBOR_PROJECT: o projeto Harbor.
SECRET: o nome do segredo criado para armazenar credenciais do Docker.

Verifique se os pods foram criados pela implementaçã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 de inquilino:

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 que implementou.

  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 um pedido POST com o cabeçalho Content-Type definido como application/json. O seguinte comando curl traduz "Hello, world!" para espanhol (es):
```
curl -X POST -H "Content-Type: application/json" -d '{"text": "Hello, world\\!", "target\_language": "es"}' http://${IP}:8080/translate
```

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

Translation API

Experimente a tradução automática