Mencoba terjemahan mesin

Cloud Translation API memungkinkan Anda menerjemahkan teks secara dinamis antarbahasa. Dalam tutorial ini, Anda akan men-deploy layanan terjemahan dalam container di Google Distributed Cloud (GDC) Sandbox tanpa GPU.

Untuk menjalankan workload yang diakselerasi GPU, lihat Men-deploy workload container GPU.

Translation API

Contoh berikut menunjukkan penggunaan Vertex AI untuk terjemahan teks.

  1. Pastikan Anda menyiapkan akses Vertex AI seperti yang dijelaskan dalam Menggunakan Vertex AI.
  2. Siapkan Python Vertex AI API, dengan mengikuti petunjuk di Panduan memulai Vertex AI menggunakan library klien. Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi Vertex AI Python API.

  3. Buat file python main.py. Skrip ini memanfaatkan Google Cloud Translation API, yang diakses menggunakan endpoint container, untuk melakukan terjemahan.

    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. Buat file docker yang berisi skrip 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. Bangun image Docker untuk aplikasi terjemahan:

    docker build -t translation-app .
    
  6. Ikuti petunjuk di Mengonfigurasi Docker untuk:

    1. Mengonfigurasi Docker,
    2. Membuat secret, dan
    3. Upload image ke HaaS (Harbor as a Service).
  7. Login ke cluster pengguna dan buat file kubeconfig-nya dengan identitas pengguna. Pastikan Anda menetapkan jalur kubeconfig sebagai variabel lingkungan:

    export KUBECONFIG=${CLUSTER_KUBECONFIG_PATH}
    
  8. Membuat dan men-deploy resource kustom Deployment dan Service Kubernetes. Untuk mengaktifkan egress container, pastikan untuk menyertakan label egress.networking.gke.io/enabled: "true", seperti yang ditunjukkan dalam contoh ini.

    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
    

    Ganti kode berikut:

    • HARBOR_INSTANCE_URL: URL instance Harbor.
    • HARBOR_PROJECT: project Harbor.
    • SECRET: nama secret yang dibuat untuk menyimpan kredensial docker.
  9. Pastikan pod telah dibuat oleh deployment:

    kubectl --kubeconfig ${KUBECONFIG} get pods -n TENANT_PROJECT
    
  10. Buat kebijakan jaringan untuk mengizinkan semua traffic jaringan ke project tenant:

    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. Ekspor alamat IP untuk layanan:

    export IP=`kubectl --kubeconfig=${KUBECONFIG} get service nginx-service \
          -n TENANT_PROJECT -o jsonpath='{.status.loadBalancer.ingress[*].ip}'`
    
  12. Buat sesi tunnel SSH ke workload yang Anda deploy.

      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. Uji layanan dengan mengirimkan payload JSON yang berisi teks dan bahasa target ke http://${IP}:8080/translate, menggunakan permintaan POST dengan header Content-Type yang ditetapkan ke application/json. Perintah curl berikut akan menerjemahkan "Hello, world!" ke dalam bahasa Spanyol (es):

    curl -X POST -H "Content-Type: application/json" -d '{"text": "Hello, world\\!", "target\_language": "es"}' http://${IP}:8080/translate