Compila aplicaciones de Python

En esta página, se describe cómo configurar Cloud Build para compilar, probar e implementar aplicaciones de Python. Si estás dando los primeros pasos en Cloud Build, lee primero las guías de inicio rápido y la descripción general de la configuración de compilación.

Cloud Build permite usar cualquier imagen de contenedor disponible a nivel público para ejecutar tareas. La imagen pública python de Docker Hub viene preinstalada con herramientas python y pip. Puedes configurar Cloud Build con estas herramientas para instalar dependencias, compilar y ejecutar pruebas de unidades con estas herramientas.

Antes de comenzar

En las instrucciones de esta página, se supone que estás familiarizado con Python. Además, ten en cuenta lo siguiente:

  • Habilita las API de Cloud Build, Cloud Run, and Artifact Registry.

    Habilita las API

  • Para ejecutar los comandos de gcloud en esta página, instala el SDK de Cloud.
  • Ten a mano tu proyecto de Python, incluido el archivo requirements.txt.
  • Si deseas crear contenedores para tu app de Python mediante Cloud Build, necesitarás un Dockerfile junto con tu código fuente.
  • Si deseas almacenar el contenedor compilado en Artifact Registry, crea un repositorio de Docker en Artifact Registry.
  • Si quieres almacenar registros de prueba en Cloud Storage, crea un bucket en Cloud Storage.

Permisos de IAM obligatorios

Para obtener instrucciones sobre cómo otorgar estas funciones, consulta Otorga una función mediante la página IAM.

Configura compilaciones de Python

En esta sección, se brinda un ejemplo de un archivo de configuración de compilación para una app de Python. Cuenta con pasos de compilación para instalar los requisitos, agregar pruebas de unidades y, después de que se aprueben, compilen e implementen la app.

  1. En el directorio raíz del proyecto, crea un archivo de configuración de Cloud Build llamado cloudbuild.yaml.

  2. Requisitos de instalación: La imagen python de Docker Hub viene preinstalada con pip. Para instalar dependencias desde pip, agrega un paso de compilación con los siguientes campos:

    • name: Establece el valor de este campo en python a fin de usar la imagen de Python desde Docker Hub para esta tarea.
    • entrypoint: Si configuras este campo, se anula el punto de entrada predeterminado de la imagen a la que se hace referencia en name. Establece el valor de este campo en pip para invocar a pip como el punto de entrada del paso de compilación y ejecuta comandos de pip.
    • args: El campo args de un paso de compilación toma una lista de argumentos y los pasa a la imagen a la que hace referencia el campo name. Pasa los argumentos para ejecutar el comando pip install en este campo. La marca --user en el comando pip install garantiza que los pasos de compilación posteriores puedan acceder a los módulos instalados en este paso de compilación.

    En el siguiente paso de compilación, se agregan argumentos para instalar los requisitos del archivo requirements.txt:

    steps:
      # Install dependencies
      - name: python
        entrypoint: pip
        args: ["install", "-r", "requirements.txt", "--user"]
  3. Agregar pruebas de unidades: si definiste pruebas de unidades en tu aplicación con un marco de trabajo de pruebas como pytest, puedes configurar Cloud Build para ejecutar las pruebas. Para ello, agrega el siguientes campos en un paso de compilación:

    • name: Establece el valor de este campo en python a fin de usar la imagen de Python desde Docker Hub para tu tarea.
    • entrypoint: Establece el valor de este campo en python para ejecutar los comandos de python.
    • args: Agrega los argumentos para ejecutar el comando python pytest.

    En el siguiente paso de compilación, se guarda el resultado del registro de pytest en un archivo XML JUNIT. El nombre de este archivo se construye con la versión corta del ID de confirmación asociado con tu compilación. Un paso de compilación posterior guardará los registros de este archivo en Cloud Storage.

    # Run unit tests
    - name: python
      entrypoint: python
      args: ["-m", "pytest", "--junitxml=${SHORT_SHA}_test_log.xml"] 
  4. Organiza la app en contenedores: Después de agregar el paso de compilación para asegurarte de que las pruebas se hayan aprobado, puedes compilar la aplicación. Cloud Build proporciona una imagen de Docker compilada con anterioridad que puedes usar para organizar tu aplicación de Python en contenedores. Para crear contenedores para tu app, agrega los siguientes campos en un paso de compilación:

    • name: Configura el valor de este campo como gcr.io/cloud-builders/docker para usar la imagen de Docker compilada previamente de Container Registry en tu tarea.
    • args: Agrega los argumentos para el comando docker build como valores para este campo.

    En el siguiente paso de compilación, se compila la imagen myimage y se etiqueta con la versión corta del ID de confirmación. En el paso de compilación, se usan las sustituciones predeterminadas por el ID del proyecto, el nombre del repositorio y los valores de SHA cortos, por lo que estos valores se sustituyen de forma automática en el momento de la compilación.

    # Docker Build
    - name: 'gcr.io/cloud-builders/docker'
      args: ['build', '-t',
             'us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/myimage:$SHORT_SHA', '.']
  5. Envía el contenedor a Artifact Registry: Puedes almacenar el contenedor compilado en Artifact Registry, un servicio de Google Cloud que puedes usar para almacenar, administrar y proteger los artefactos de compilación. Para ello, deberás tener un repositorio de Docker existente en Artifact Registry. Si deseas configurar Cloud Build para almacenar la imagen en un repositorio de Docker de Artifact Registry, agrega un paso de compilación con los siguientes campos:

    • name: Establece el valor de este campo en gcr.io/cloud-builders/docker a fin de usar la imagen oficial del compilador docker de Container Registry para tu tarea.
    • args: Agrega los argumentos para el comando docker push como valores de este campo. Para la URL de destino, ingresa el repositorio de Docker de Artifact Registry en el que deseas almacenar la imagen.

    En el siguiente paso de compilación, se envía la imagen que compilaste en el paso anterior a Artifact Registry:

    # Docker push to Google Artifact Registry
    - name: 'gcr.io/cloud-builders/docker'
      args: ['push',  'us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/myimage:$SHORT_SHA']
  6. Implementa el contenedor en Cloud Run: Para implementar la imagen en Cloud Run, agrega un paso de compilación con los siguientes campos:

    • name: Establece el valor de este campo en google/cloud-sdk para usar la imagen del SDK de Cloud a fin de invocar el comando gcloud a fin de implementar la imagen en Cloud Run.
    • args: Agrega los argumentos para el comando gcloud run deploy como valores de este campo.

    En el siguiente paso de compilación, se implementa la imagen compilada con anterioridad en Cloud Run:

    # Deploy to Cloud Run
    - name: google/cloud-sdk
      args: ['gcloud', 'run', 'deploy', 'helloworld',
             '--image=us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/myimage:$SHORT_SHA',
             '--region', 'us-central1', '--platform', 'managed',
             '--allow-unauthenticated']
  7. Guardar registros de prueba en Cloud Storage: Puedes configurar Cloud Build para almacenar cualquier registro de prueba en Cloud Storage si especificas una ubicación de bucket existente y una ruta de acceso a los registros de prueba. En el siguiente paso de compilación, se almacenan los registros de prueba que guardaste en el archivo XML de JUNIT en un bucket de Cloud Storage:

    # Save test logs to Google Cloud Storage
    artifacts:
      objects:
        location: gs://$_BUCKET_NAME/
        paths:
          - ${SHORT_SHA}_test_log.xml

    En el siguiente fragmento, se muestra el archivo de configuración de compilación completo para todos los pasos descritos antes:

    steps:
      # Install dependencies
      - name: python
        entrypoint: pip
        args: ["install", "-r", "requirements.txt", "--user"]
    
      # Run unit tests
      - name: python
        entrypoint: python
        args: ["-m", "pytest", "--junitxml=${SHORT_SHA}_test_log.xml"]
    
      # Docker Build
      - name: 'gcr.io/cloud-builders/docker'
        args: ['build', '-t',
               'us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/myimage:$SHORT_SHA', '.']
    
      # Docker push to Google Artifact Registry
      - name: 'gcr.io/cloud-builders/docker'
        args: ['push',  'us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/myimage:$SHORT_SHA']
    
      # Deploy to Cloud Run
      - name: google/cloud-sdk
        args: ['gcloud', 'run', 'deploy', 'helloworld',
               '--image=us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/myimage:$SHORT_SHA',
               '--region', 'us-central1', '--platform', 'managed',
               '--allow-unauthenticated']
    
    # Save test logs to Google Cloud Storage
    artifacts:
      objects:
        location: gs://$_BUCKET_NAME/
        paths:
          - ${SHORT_SHA}_test_log.xml
    # Store images in Google Artifact Registry
    images:
      - us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/myimage:$SHORT_SHA
  8. Inicia la compilación de forma manual o usa activadores de compilación.

¿Qué sigue?