Esta página se ha traducido con Cloud Translation API.

Probar la traducción automática

En esta página se muestra un ejemplo de cómo usar la API de Vertex AI para traducir texto de un idioma a otro.

En este ejemplo, desplegarás las cargas de trabajo sin usar GPUs. Para implementar con GPUs, sigue los pasos que se indican en Implementar cargas de trabajo de contenedores de GPU.

API de Translation

En el siguiente ejemplo se muestra cómo usar Vertex AI para traducir texto.

Asegúrate de configurar el acceso a Vertex AI tal como se describe en el artículo Usar Vertex AI.
Configura la API de Vertex AI de Python siguiendo las instrucciones de la guía de inicio rápido de Vertex AI con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API de Python de Vertex AI.

Crea un archivo de Python main.py. Esta secuencia de comandos aprovecha la Google CloudAPI Translation, a la que se accede mediante un endpoint de contenedor, para realizar traducciones.

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)

Crea un archivo de Docker que contenga la secuencia de comandos de 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"]

Compila la imagen Docker de la aplicación de traducción:
```
docker build -t translation-app .
```
Sigue las instrucciones de Configurar Docker para hacer lo siguiente:
1. Configura Docker.
2. Crea un secreto y
3. Sube la imagen a HaaS (Harbor como servicio).
Inicia sesión en el clúster de usuario y genera su archivo kubeconfig con una identidad de usuario. Asegúrate de definir la ruta de kubeconfig como variable de entorno:
```
export KUBECONFIG=${CLUSTER_KUBECONFIG_PATH}
```

Crea e implementa los recursos personalizados de Kubernetes Deployment y Service. Para habilitar la salida del contenedor, asegúrate de incluir la etiqueta egress.networking.gke.io/enabled: "true", tal como se muestra en este ejemplo.

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

Haz los cambios siguientes:

HARBOR_INSTANCE_URL: la URL de la instancia de Harbor.
HARBOR_PROJECT: el proyecto de Harbor.
SECRET: el nombre del secreto creado para almacenar las credenciales de Docker.

Verifica que el despliegue haya creado los pods:

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

Crea una política de red para permitir todo el tráfico de red al proyecto 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

Exporta la dirección IP del servicio:

export IP=`kubectl --kubeconfig=${KUBECONFIG} get service nginx-service \
      -n TENANT_PROJECT -o jsonpath='{.status.loadBalancer.ingress[*].ip}'`

Crea una sesión de túnel SSH para la carga de trabajo que has implementado.

  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

Prueba el servicio enviando una carga útil JSON con el texto y el idioma de destino a http://${IP}:8080/translate mediante una solicitud POST con el encabezado Content-Type definido como application/json. El siguiente comando curl traducirá "Hello, world!" al español (es):
```
curl -X POST -H "Content-Type: application/json" -d '{"text": "Hello, world\\!", "target\_language": "es"}' http://${IP}:8080/translate
```

Probar la traducción automática Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

API de Translation

Probar la traducción automática