Prueba el reconocimiento óptico de caracteres (OCR)

El reconocimiento óptico de caracteres (OCR) con la API de Cloud Vision te permite extraer texto impreso y escrito a mano de las imágenes. En este instructivo, alojarás en contenedores un cliente de Python que ejecuta OCR en una imagen y lo implementarás como un trabajo en Google Distributed Cloud (GDC) Sandbox.

Para ejecutar esta carga de trabajo, necesitas un proyecto de Google Cloud activo con la API de Cloud Vision habilitada, una clave de API válida y acceso a tu instancia de GDC Sandbox y al registro de contenedores de Harbor. Antes de probar este ejemplo, sigue las instrucciones de configuración para Python incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta Usa Vertex AI y la documentación de referencia de la API de Python de Vertex AI.

1. Crea un archivo de Python ocr_test.py. Reemplaza el valor image_uri_to_test por el URI de una imagen de origen, como se muestra a continuación:

   import os
   import requests
   import json
   
   def detect_text_rest(image_uri):
       """Performs Optical Character Recognition (OCR) on an image by invoking the Vertex AI REST API."""
   
       # Securely fetch the API key from environment variables
       api_key = os.environ.get("GCP_API_KEY")
       if not api_key:
           raise ValueError("GCP_API_KEY environment variable must be defined.")
   
       # Construct the Vision API endpoint URL
       vision_api_url = f"https://vision.googleapis.com/v1/images:annotate?key={api_key}"
   
       print(f"Initiating OCR process for image: {image_uri}")
   
       # Define the request payload for text detection
       request_payload = {
           "requests": [
               {
                   "image": {
                       "source": {
                           "imageUri": image_uri
                       }
                   },
                   "features": [
                       {
                           "type": "TEXT_DETECTION"
                       }
                   ]
               }
           ]
       }
   
       # Send a POST request to the Vision API
       response = requests.post(vision_api_url, json=request_payload)
       response.raise_for_status()  # Check for HTTP errors
   
       response_json = response.json()
   
       print("\n--- OCR Results ---")
   
       # Extract and print the detected text
       if "textAnnotations" in response_json["responses"]:
           full_text = response_json["responses"]["textAnnotations"]["description"]
           print(f"Detected Text:\n{full_text}")
       else:
           print("No text was detected in the image.")
   
       print("--- End of Results ---\n")
   
   if __name__ == "__main__":
       # URI of a publicly available image, or a storage bucket
       image_uri_to_test = "IMAGE_URI"
   
       detect_text_rest(image_uri_to_test)
   

   Reemplaza lo siguiente:

   • IMAGE_URI por el URI de una imagen disponible de forma pública que contenga texto, por ejemplo, "https://cloud.google.com/vision/docs/images/sign.jpg". Como alternativa, puedes especificar un URI de Cloud Storage, por ejemplo, "gs://your-bucket/your-image.png".

2. Crea un Dockerfile:

   ROM python:3.9-slim
   
   WORKDIR /app
   
   COPY ocr_test.py /app/
   
   # Install 'requests' for HTTP calls
   RUN pip install --no-cache-dir requests
   
   CMD ["python", "ocr_test.py"]
   

3. Compila la imagen de Docker para la aplicación de traducción:

   docker build -t ocr-app .
   

4. Sigue las instrucciones que se indican en Configura Docker para hacer lo siguiente:

   1. Configura Docker.
   2. Crear un secreto
   3. Sube la imagen a HaaS.

5. Accede al clúster de usuario y genera su archivo kubeconfig con una identidad de usuario. Asegúrate de configurar la ruta de acceso de kubeconfig como una variable de entorno:

   export KUBECONFIG=${CLUSTER_KUBECONFIG_PATH}
   

6. Para crear un Secret de Kubernetes, ejecuta el siguiente comando en tu terminal y pega tu clave de API:

   kubectl create secret generic gcp-api-key-secret \
     --from-literal=GCP_API_KEY='PASTE_YOUR_API_KEY_HERE'
   

   Este comando crea un Secret llamado gcp-api-key-secret con una clave GCP_API_KEY.

7. Aplica el manifiesto de Kubernetes:

   apiVersion: batch/v1
   kind: Job
   metadata:
     name: ocr-test-job-apikey
   spec:
     template:
       spec:
         containers:
         - name: ocr-test-container
           image: HARBOR_INSTANCE_URL/HARBOR_PROJECT/ocr-app:latest # Your image path
           # Mount the API key from the secret into the container
           # as an environment variable named GCP_API_KEY.
           imagePullSecrets:
           - name: ${SECRET}
           envFrom:
           - secretRef:
               name: gcp-api-key-secret
         restartPolicy: Never
     backoffLimit: 4
   
   

   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 Secret creado para almacenar las credenciales de Docker.

8. Verifica el estado del trabajo:

   kubectl get jobs/ocr-test-job-apikey
   # It will show 0/1 completions, then 1/1 after it succeeds
   

9. Una vez que se complete el trabajo, podrás ver el resultado del OCR en los registros del Pod:

   kubectl logs -l job-name=ocr-test-job-apikey