Se usó la API de Cloud Translation para traducir esta página.

Prueba la traducción automática

En esta página, se muestra un ejemplo del uso de la API de Vertex AI para traducir texto de un idioma a otro.

En este ejemplo, implementarás las cargas de trabajo sin usar GPUs. Para realizar la implementación con GPUs, sigue los pasos que se indican en Implementa cargas de trabajo de contenedores con GPU.

API de Translation

En el siguiente ejemplo, se muestra el uso de Vertex AI para la traducción de texto.

Asegúrate de configurar el acceso a Vertex AI como se describe en Cómo 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 sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Vertex AI para Python.

Crea un archivo de Python main.py. Esta secuencia de comandos aprovecha la API de Translation Google Cloud, a la que se accede con un extremo 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 de Docker para la aplicación de traducción:
```
docker build -t translation-app .
```
Sigue las instrucciones en Configura Docker para hacer lo siguiente:
1. Configura Docker.
2. Crea un secreto.
3. Sube la imagen a HaaS (Harbor como servicio).
Accede al clúster de usuario y genera su archivo kubeconfig con una identidad de usuario. Asegúrate de configurar la ruta de kubeconfig como una variable de entorno:
```
export KUBECONFIG=${CLUSTER_KUBECONFIG_PATH}
```

Crea e implementa los recursos personalizados de Deployment y Service de Kubernetes. Para habilitar la salida del contenedor, asegúrate de incluir la etiqueta egress.networking.gke.io/enabled: "true", 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

Reemplaza lo siguiente:

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

Verifica que la implementación 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 del arrendatario:

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 implementaste.

  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

Para probar el servicio, envía una carga útil JSON con el texto y el idioma de destino a http://${IP}:8080/translate, con una solicitud POST con el encabezado Content-Type establecido en 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
```

Prueba la traducción automática Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

API de Translation

Prueba la traducción automática