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

‫Cloud Translation API מאפשר לתרגם טקסט באופן דינמי בין שפות. במדריך הזה תפרסו שירות תרגום בקונטיינר ב-Google Distributed Cloud (GDC) Sandbox בלי מעבדים גרפיים.

כדי להריץ עומסי עבודה מבוססי-GPU, קראו את המאמר פריסת עומסי עבודה של קונטיינרים של GPU.

Translation API

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

  1. חשוב לוודא שהגדרתם את הגישה ל-Vertex AI כמו שמתואר במאמר שימוש ב-Vertex AI.
  2. מגדירים את Vertex AI API ב-Python לפי ההוראות במדריך התחלה מהירה של 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 as a Service).
  7. נכנסים לאשכול המשתמש ויוצרים את קובץ ה-kubeconfig שלו עם זהות משתמש. חשוב לוודא שהגדרתם את הנתיב של kubeconfig כמשתנה סביבה:

    export KUBECONFIG=${CLUSTER_KUBECONFIG_PATH}
    
  8. יוצרים ופורסים את המשאבים המותאמים אישית של הפריסה והשירות של Kubernetes. כדי לאפשר תעבורת נתונים יוצאת מהקונטיינר, צריך לכלול את התווית 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. יוצרים מדיניות רשת ב-Kubernetes שמאפשרת את כל התנועה ברשת לפרויקט הדייר (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. מייצאים את כתובת ה-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