איך משתמשים בתרגום אוטומטי

בדף הזה מוסבר איך להשתמש ב-Vertex AI API כדי לתרגם טקסט משפה אחת לשפה אחרת.

בדוגמה הזו, אתם פורסים את עומסי העבודה בלי להשתמש במעבדי GPU. כדי לבצע פריסה באמצעות יחידות GPU, פועלים לפי השלבים במאמר בנושא פריסת עומסי עבודה של קונטיינרים של GPU.

Translation API

בדוגמה הבאה מוצג שימוש ב-Vertex AI לתרגום טקסט.

1. חשוב לוודא שהגדרתם גישה ל-Vertex AI כמו שמתואר במאמר שימוש ב-Vertex AI.

2. מגדירים את Python Vertex AI API לפי ההוראות שבמדריך לתחילת העבודה עם Vertex AI באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של ה-API בשפת Python של Vertex AI.

3. יוצרים קובץ Python‏ main.py. הסקריפט הזה משתמש ב- Google CloudTranslation API, שאליו ניגשים באמצעות נקודת קצה של מאגר, כדי לבצע תרגומים.

   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. יוצרים קובץ Docker שמכיל את סקריפט 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. יוצרים את קובץ האימג' של Docker לאפליקציית התרגום:

   docker build -t translation-app .
   

6. פועלים לפי ההוראות במאמר הגדרת Docker כדי:

   1. מגדירים את Docker,
   2. יוצרים סוד, ו
   3. מעלים את התמונה ל-HaaS (Harbor כשירות).

7. נכנסים לאשכול המשתמשים ויוצרים את קובץ ה-kubeconfig שלו עם זהות משתמש. חשוב להגדיר את הנתיב של kubeconfig כמשתנה סביבה:

   export KUBECONFIG=${CLUSTER_KUBECONFIG_PATH}
   

8. יצירה ופריסה של משאבים מותאמים אישית של Kubernetes Deployment ו-Service. כדי להפעיל יציאה של קונטיינר, חשוב לכלול את התווית egress.networking.gke.io/enabled: "true", כמו בדוגמה הזו.

   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
   

   מחליפים את מה שכתוב בשדות הבאים:

   • ‫HARBOR_INSTANCE_URL: כתובת ה-URL של מופע Harbor.
   • ‫HARBOR_PROJECT: פרויקט Harbor.
   • ‫SECRET: השם של הסוד שנוצר לאחסון פרטי הכניסה של Docker.

9. בודקים שה-pods נוצרו על ידי הפריסה:

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

10. יוצרים מדיניות רשת כדי לאפשר את כל תעבורת הנתונים ברשת לפרויקט הדייר:

    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. מייצאים את כתובת ה-IP של השירות:

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

12. יוצרים סשן של מנהרת SSH לעומס העבודה שפרסתם.

      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. בודקים את השירות על ידי שליחת מטען ייעודי (payload) בפורמט JSON עם הטקסט ושפת היעד אל http://${IP}:8080/translate, באמצעות בקשת POST עם הכותרת Content-Type שמוגדרת לערך application/json. הפקודה הבאה של curl תתרגם את המחרוזת Hello, world!‎ לספרדית (es):

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