Implementación

En esta página, se describe cómo implementar el generador de configuración de métricas (MCG).

Accede al código fuente

El código fuente de MCG se aloja en GitHub, en aaos-sdv-telemetry-mcg. Puedes ejecutar MCG de forma local para el desarrollo y las pruebas, o implementarlo en un entorno de nube para el acceso del equipo.

Ejecuta de forma local

Para ejecutar MCG desde su directorio del código fuente para el desarrollo y las pruebas locales, usa Bazel. Bazel debe estar instalado. Debes habilitar el almacenamiento en caché en la memoria configurando MCG_LOCALCACHE=true cuando se ejecuta de forma local. Esto admite el almacenamiento de catálogos de indicadores de vehículos. Para compilar y ejecutar el servicio de forma local, usa los siguientes comandos desde el directorio del código fuente:

# Build and run on default port 8005
MCG_LOCALCACHE=true bazel run //:mcg

# Or, to change the port, use:
MCG_LOCALCACHE=true bazel run //:mcg -- --listen :9000

Implementa el notebook en Google Cloud

La base de código de MCG incluye archivos de Terraform y Google Cloud Build para implementar MCG en Google Cloud como un servicio de Google Cloud Run. En las siguientes secciones, se te guiará a través del proceso de implementación, que incluye crear un archivo de variables, implementar la infraestructura, compilar e implementar la aplicación, otorgar acceso y verificar la implementación.

Como Cloud Run es una plataforma sin servidores, conserva los recursos, ya que solo ejecuta contenedores cuando procesa solicitudes, en lugar de mantener un servidor activo las 24 horas, todos los días. Esto significa que los datos en memoria se pierden cuando las instancias de contenedor se cierran entre solicitudes. Por lo tanto, se requiere Redis para proporcionar almacenamiento persistente para los datos del catálogo en las invocaciones de servicio. Este enfoque proporciona una implementación escalable adecuada para el uso en equipo o en producción.

Requisitos previos

Antes de comenzar la implementación en Google Cloud, verifica que cumplas con los siguientes requisitos previos:

Estructura de archivos

La implementación en Google Cloud implica ejecutar comandos de Terraform desde el subdirectorio infrastructure/ y comandos de Cloud Build desde la raíz del repositorio. Los archivos y directorios principales con los que interactúas son los siguientes:

repository-root/
├── cloudbuild.yaml
└── infrastructure/
    └── terraform.tfvars  <-- you create this file

Crea un archivo de variables de Terraform

En el directorio infrastructure/, crea un archivo llamado terraform.tfvars para proporcionar valores para las variables definidas en variables.tf y personalizar tu implementación. Debes definir los valores de project_id y region en este archivo; todas las demás variables son opcionales. Agrega el siguiente código a terraform.tfvars:

project_id        = "your-gcp-project-id"
region            = "your-gcp-region" # For example, us-central1 or europe-west1

Consulta variables.tf para ver todas las variables disponibles y sus valores predeterminados. Puedes anular los valores predeterminados si los configuras en terraform.tfvars.

Implementa la infraestructura

Después de crear terraform.tfvars, puedes inicializar y aplicar la configuración de Terraform. En este paso, se aprovisionan todos los recursos de Google Cloud necesarios, incluidos Artifact Registry, Redis y Cloud Run. Cuando se complete, Terraform creará el servicio de Google Cloud Run, que ejecuta una imagen de contenedor de marcador de posición. Este paso puede tardar varios minutos.

# Run from the infrastructure/ directory
terraform init
terraform apply

Cuando terraform apply te lo solicite, revisa el plan y escribe yes para confirmar.

Compila e implementa la aplicación de MCG

Después de aprovisionar la infraestructura, el siguiente paso es compilar el código fuente de MCG y, luego, implementarlo en Google Cloud Run. Para ello, se envía el código fuente a Google Cloud Build, que compila la imagen de Docker, la envía a Artifact Registry y actualiza el servicio de Google Cloud Run para que use la imagen nueva.

Google Cloud Build usa la variable de sustitución COMMIT_SHA para etiquetar la imagen compilada. Puedes usar un número de versión (por ejemplo, v1.0.0) o el SHA de confirmación de tu repositorio. El etiquetado te ayuda a distinguir entre las versiones en Artifact Registry, administrar las implementaciones y revertir a una versión anterior si es necesario.

Ejecuta el siguiente comando de gcloud para activar la compilación y la implementación:

# Run from the repository root
#
# The command tags the image with the Git commit SHA.
# To tag with a version number, replace '$(git rev-parse --short HEAD)' with the version number.
gcloud builds submit . \
  --config=cloudbuild.yaml \
  --substitutions=COMMIT_SHA=$(git rev-parse --short HEAD)

Este comando realiza la implementación inicial del código de la aplicación. Para implementar actualizaciones en el código fuente de MCG, vuelve a ejecutar este comando.

Otorga acceso y verifica la implementación

Para permitir que los usuarios o las cuentas de servicio llamen a la API de MCG, debes otorgarles el rol de IAM de Invocador de Cloud Run (roles/run.invoker):

gcloud run services add-iam-policy-binding mcg-service \
  --member=MEMBER_TYPE:EMAIL_ADDRESS \
  --role=roles/run.invoker \
  --region=your-gcp-region

Puedes obtener la URL del servicio ejecutando el siguiente comando. La URL permanece estable en todas las implementaciones.

SERVICE_URL=$(gcloud run services describe mcg-service \
  --region your-gcp-region \
  --format='value(status.url)')

Después de otorgar los permisos, llama al extremo /health para confirmar que el servicio se esté ejecutando y sea accesible. Debido a que los servicios de Google Cloud Run requieren autenticación, debes incluir un token de autorización de gcloud en el encabezado de la solicitud cuando llames al extremo:

curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
  $SERVICE_URL/health

Si el servicio se está ejecutando, este comando devuelve OK y, ahora, puedes llamar a cualquiera de los endpoints de la API, como se describe en Llama a la API.