Usar flujos de procesamiento sin servidor con Active Assist

Last reviewed 2021-06-09 UTC

Este documento está dirigido a arquitectos empresariales y desarrolladores de software que quieran crear una canalización de automatización para usar Active Assist en su organización. Google Cloud Forma parte de una serie en la que se analizan patrones de arquitectura que las empresas pueden usar para optimizar su presencia en la nube a gran escala con Active Assist. La serie consta de las siguientes partes:

En este tutorial se explica cómo usar Google Cloud tecnologías sin servidor para crear una canalización de automatización que recupere y procese las recomendaciones de Active Assist. Las recomendaciones se basan en las reglas de negocio definidas por tu empresa. La canalización de automatización que has configurado en este tutorial te ayuda a trabajar con Active Assist a gran escala sin dejar de mantener un proceso de revisión y activación dirigido por el equipo. Este enfoque es útil cuando tu empresa quiere ampliar el uso de la cartera de Active Assist, pero quiere mantener el control del proceso de revisión y activación en los equipos. Ofrece una alternativa al uso de un flujo de procesamiento de integración continua y entrega continua (CI/CD).

La arquitectura que se muestra en este tutorial es genérica y puedes ampliarla para que funcione con otros productos sin servidor. En este tutorial se da por hecho que conoces las siguientes tecnologías: Google Cloud

Para completar este tutorial, debes tener una cuenta de Slack o una herramienta similar de notificaciones o de procesamiento de incidencias. La herramienta debe estar configurada en tu máquina y lista para usarse.

Arquitectura

Como la arquitectura que se muestra en este tutorial es modular, puedes adaptar el componente de notificaciones a los requisitos de tu empresa. En este tutorial se muestra cómo generar notificaciones y enviarlas a Slack. También puedes enviar notificaciones a Pub/Sub o a cualquier otra herramienta de procesamiento de notificaciones o incidencias.

En el siguiente diagrama de arquitectura se muestran los componentes que se usan en este tutorial:

Flujo de procesamiento sin servidor.

La arquitectura tiene los siguientes componentes:

  • Un servicio de Cloud Run que un programador activa a intervalos fijos. El servicio invoca las APIs Recommender leyendo los metadatos (IDs de proyecto y tipos de recomendación) que se definen y almacenan en una colección de Firestore.
  • Un tema de Pub/Sub en el que se insertan y procesan las recomendaciones de Active Assist.
  • Un segundo servicio de Cloud Run que analiza las recomendaciones de Active Assist. Este servicio determina cómo se procesan las recomendaciones en función de las reglas de negocio definidas por tu empresa y almacenadas en una colección de Firestore.
  • Dos colecciones de Firestore para almacenar los metadatos y las reglas de negocio. Las colecciones de Firestore funcionan de la siguiente manera:
    • La primera colección almacena los metadatos de la empresa relevantes para obtener recomendaciones de Active Assist. En este tutorial, los atributos recommendation type, Google Cloud project IDs y locations se usan como metadatos empresariales. El servicio recommendation-collector de Cloud Run usa estos atributos para determinar qué tipos de recomendaciones se obtienen.
    • La segunda colección almacena las reglas de negocio que se aplican cuando se procesan las recomendaciones.

Objetivos

  • Crea un servicio de Cloud Run de ejemplo para obtener recomendaciones de Asistencia activa de un proyecto de ejemplo e insertarlas en un tema de Pub/Sub.
  • Crea dos colecciones de Firestore para almacenar metadatos de ejemplo y reglas de negocio, respectivamente.
  • Crea un segundo servicio de Cloud Run para procesar recomendaciones según las reglas de negocio de ejemplo que definas en este tutorial.
  • Crea un canal de Slack al que el servicio de Cloud Run envíe recomendaciones de ejemplo de Active Assist.
  • Prueba la canalización completa con recomendaciones de Active Assist de ejemplo.

Costes

En este documento, se utilizan los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costes basada en el uso previsto, utiliza la calculadora de precios.

Los usuarios nuevos Google Cloud pueden disfrutar de una prueba gratuita.

Cuando termines las tareas que se describen en este documento, puedes evitar que se te siga facturando eliminando los recursos que has creado. Para obtener más información, consulta la sección Limpiar.

Antes de empezar

  1. In the Google Cloud console, go to the project selector page.

    Go to project selector

  2. Select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
  3. Anota el ID del proyecto del gestor de recomendaciones. Google Cloud Necesitarás este ID en la siguiente sección para configurar tu entorno.

  4. Enable the Cloud Build, Firestore, App Engine,Pub/Sub, Cloud Run, Cloud Scheduler, and Cloud Source Repositories APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

    En este tutorial, se usan las credenciales de aplicación predeterminadas. Si se te pide que crees credenciales en la página Añadir credenciales a tu proyecto, haz clic en Cancelar.

  5. Verify that billing is enabled for your Google Cloud project.

  6. Crea lo siguiente:
    • Un canal de Slack de ejemplo.
    • Una aplicación de Slack de ejemplo y un webhook entrante para recibir notificaciones generadas por un motor llamado recommendation-rules-engine. Configurarás el motor más adelante en este tutorial.
    Para obtener más información, consulta los artículos Crear un canal de Slack y Enviar mensajes mediante webhooks entrantes.

    Cuando hayas creado una aplicación de Slack y una URL de webhook entrante, anota la URL, ya que la necesitarás más adelante en este tutorial.

Crear el flujo de procesamiento sin servidor

En esta sección, creará los componentes que necesita para crear la canalización sin servidor. La plataforma genera recomendaciones de Active Assist basadas en patrones de uso y métricas del sistema. En función de las recomendaciones que se generen, cada categoría de recomendación puede usar un periodo predeterminado diferente del pasado para analizar los datos de uso y las métricas.

Si tienes un proyecto de ejemplo Google Cloud que tiene recursos y recomendaciones de Active Assist, puedes ejecutar la canalización para procesar esas recomendaciones después de hacer los cambios oportunos en el código de ejemplo proporcionado.

Crear las colecciones de Firestore

En esta sección, crearás dos colecciones de Firestore. La primera, la colección activeassist-metadata, almacena los metadatos de la empresa relevantes para obtener recomendaciones de Asistencia activa. La segunda, la colección activeassist-business-rules, almacena las reglas de negocio que se aplican cuando la canalización procesa las recomendaciones.

Cuando se analizan las recomendaciones de Active Assist, en función de las reglas de negocio de la colección de Firestore, se genera y se envía una notificación, o bien la recomendación se aplica automáticamente al recurso correspondiente. Google Cloud

Crea la colección activeassist-metadata

  1. En la Google Cloud consola, ve a la página de Firestore.

    Abrir Firestore

  2. Crea una base de datos de Firestore si aún no tienes una. Si ya tienes una base de datos de Firestore, ve al siguiente paso.

    Crea la base de datos:

    1. Haz clic en Seleccionar modo nativo para activar Firestore.
    2. Selecciona una región cercana a la región en la que se ejecutan tus servicios de Cloud Run.
    3. Haz clic en Crear base de datos. La configuración tarda unos minutos en completarse.

  3. En la página de Firestore, haga clic en Start Collection (Iniciar colección).

  4. En el campo ID de colección, introduzca lo siguiente: activeassist-metadata.

  5. Rellena los campos tal como se muestra en la siguiente tabla. Para añadir el siguiente campo, haz clic en Añadir campo.

    Nombre del campo Tipo de campo Valor de campo Nota
    project string Stub-Project-ID En este tutorial se usa un stub para el valor del campo. Si quieres usar las recomendaciones de un proyecto de Google Cloud , introduce el ID del proyecto.
    locations array global Algunas recomendaciones pueden ser específicas de una región o una zona, como las recomendaciones de reajuste de tamaño de máquinas virtuales. Otras recomendaciones son globales, como las de gestión de identidades y accesos.
    recommenderType string google.iam.policy.Recommender No aplicable

  6. Cuando se hayan rellenado los campos, haz clic en Guardar.

Crea la colección activeassist-business-rules

  1. Haz clic en Iniciar colección.

  2. En el campo ID de colección, introduce lo siguiente: activeassist-business-rules.

    Rellena el documento tal como se muestra en la siguiente tabla. Para añadir el siguiente campo, haz clic en Añadir campo.

    Nombre del campo Tipo de campo Valor de campo Nota
    action string Notify Si asigna el valor Apply, el servicio aplicará la recomendación y quitará el rol que no se utilice.
    projectId string Stub-Project-ID En este tutorial se usa una recomendación de stub. Si quieres usar las recomendaciones de un proyecto de Google Cloud , introduce el ID del proyecto.
    projectNumber string 999999999 En este tutorial se usa una recomendación de stub.

    Si usas una recomendación de un proyecto Google Cloud , introduce el número del proyecto. Puedes encontrar el número de proyecto en la Google Cloud página de bienvenida de la consola.
    recommenderType string google.iam.policy.Recommender No aplicable
    recommenderSubtype string REMOVE_ROLE No aplicable
    slackWebhookURL string Introduce la URL del webhook de Slack que has generado en un paso anterior. La URL es similar a la siguiente:

    https://hooks.slack.com/services/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

    En este tutorial se explica cómo crear una regla para determinar si una recomendación se aplica automáticamente o si se genera una notificación y se envía a una plataforma como Slack. Para saber cómo se puede aplicar una recomendación automáticamente en función de la evaluación de las reglas de negocio de ejemplo que hayas configurado, consulta el repositorio asociado.

  3. Cuando se haya rellenado el documento, haga clic en Guardar.

Crear un servicio de Cloud Run programado

En esta sección, crearás un servicio de Cloud Run programado llamado recommendation-collector que invoca la API Recommender y obtiene recomendaciones activas. En este tutorial, se utiliza la API Recommender de gestión de identidades y accesos como API Recommender. El servicio lee los metadatos de la colección activeassist-metadata de Firestore que has creado para determinar qué recomendaciones debe obtener.

  1. Haz clic en Abrir en Cloud Shell para abrir Cloud Shell en el proyecto del gestor de recomendaciones.

    Abrir en Cloud Shell

    Cuando se abra Cloud Shell, se ejecutarán los siguientes comandos:

    Cuando aparezca el cuadro de diálogo Abrir en Cloud Shell, selecciona Confiar y, a continuación, haz clic en Confirmar.

  2. Define el ID y el número del proyecto de Recommendation Manager actual como variables:

    export RECO_MGR_PROJECT=PROJECT_ID
gcloud config set project $RECO_MGR_PROJECT
export RECO_MGR_PROJECT_NUMBER=$(gcloud projects describe $DEVSHELL_PROJECT_ID --format='value(projectNumber)')

    Sustituye PROJECT_ID por el ID del proyecto. Una vez que hayas introducido los comandos, haz clic en Autorizar cuando se te solicite.

  3. Define la variable de la región de implementación:

    export REGION=us-central1

    Aunque en este tutorial se usa la región us-central1, puedes usar cualquier región en la que esté disponible Cloud Run.

  4. Crea una variable de entorno para tu imagen Docker:

    export RECOMMENDER_IMAGE=gcr.io/$RECO_MGR_PROJECT/recommendation-collector:1.0

  5. Crea la imagen Docker y súbela a Container Registry:

     gcloud builds submit --tag $RECOMMENDER_IMAGE

  6. Crea una cuenta de servicio para que el servicio recommendation-collector interactúe con otros servicios de la canalización: Google Cloud 

    gcloud iam service-accounts create recommendation-collector-sa \
  --description "Service Account that the recommendation-collector service uses to invoke other Google Cloud services" \
  --display-name "recommendation-collector-sa" \
  --project $RECO_MGR_PROJECT

    Es recomendable conceder permisos granulares a tus servicios de Cloud Run asignando roles predefinidos a la cuenta de servicio. Para obtener más información, consulta Identidad de servicio.

  7. Da a la cuenta de servicio del servicio recommendation-collector acceso a Firestore y a la API Recommender:

    gcloud projects add-iam-policy-binding $RECO_MGR_PROJECT \
  --member serviceAccount:recommendation-collector-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/datastore.user
gcloud projects add-iam-policy-binding $RECO_MGR_PROJECT \
  --member serviceAccount:recommendation-collector-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/pubsub.publisher

  8. Si estás siguiendo este tutorial con el ejemplo stub proporcionado en el repositorio que has clonado, ve al siguiente paso.

    Si vas a crear la canalización de este tutorial con las recomendaciones generadas para un proyecto de Google Cloud , debes asignar permisos de gestión de identidades y accesos a las cuentas de servicio que has creado para ejecutar los dos servicios de Cloud Run.

    Define una variable de entorno, TEST_PROJECT_ID, con el ID del proyecto para el que ejecutas esta canalización antes de ejecutar los comandos:

    export TEST_PROJECT_ID=TEST_PROJECT_ID
gcloud projects add-iam-policy-binding $TEST_PROJECT_ID \
  --member serviceAccount:recommendation-collector-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/recommender.iamAdmin
gcloud projects add-iam-policy-binding $TEST_PROJECT_ID \
  --member serviceAccount:recommendation-collector-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/serviceusage.serviceUsageConsumer
gcloud services enable recommender.googleapis.com --project $TEST_PROJECT_ID

    Asegúrate de que el ID de proyecto que usas coincide con el que introdujiste al crear las colecciones de Firestore.

  9. En este tutorial, desplegarás el servicio con una variable de entorno llamada STUB_RECOMMENDATIONS. Esta variable te permite usar un stub para probar la pipeline.

    Despliega el servicio de Cloud Run:

    gcloud run deploy recommendation-collector \
  --image=$RECOMMENDER_IMAGE \
  --no-allow-unauthenticated \
  --region $REGION \
  --platform managed \
  --service-account recommendation-collector-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --set-env-vars="STUB_RECOMMENDATIONS=true" \
  --project $RECO_MGR_PROJECT \

    Acepta las peticiones del sistema.

    Si quieres ejecutar la canalización con las recomendaciones de Active Assist generadas para un proyecto Google Cloud , quita la siguiente línea del comando antes de implementarlo:

    --set-env-vars="STUB_RECOMMENDATIONS=true"

Configurar una tarea de Cloud Scheduler para ejecutar el recommender-collector service

  1. En Cloud Shell, crea una cuenta de servicio para que las tareas de Cloud Scheduler la usen para ejecutar el servicio recommendation-collector:

    gcloud iam service-accounts create recommender-scheduler-sa \
  --description "Service Account used by Cloud Scheduler to invoke the recommender-parser service" \
  --display-name "recommender-scheduler-sa" \
  --project $RECO_MGR_PROJECT

  2. Asigna el rol run/invoker a la cuenta de servicio para que pueda invocar el servicio de Cloud Run:

    gcloud run services add-iam-policy-binding recommendation-collector \
  --member=serviceAccount:recommender-scheduler-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role=roles/run.invoker \
  --region=$REGION \
  --platform=managed

  3. Obtén la URL del servicio recommendation-collector:

    export RECOMMENDER_SERVICE_URI=`gcloud run services describe recommendation-collector \
  --platform managed \
  --project $RECO_MGR_PROJECT \
  --region $REGION \
  --format="value(status.url)"`/run

  4. Crea una tarea de Cloud Scheduler llamada recommender-iam-scheduler:

    gcloud scheduler jobs create http recommender-iam-scheduler \
  --project $RECO_MGR_PROJECT \
  --time-zone "America/Los_Angeles" \
  --schedule="0 */3 * * *" \
  --uri=$RECOMMENDER_SERVICE_URI \
  --description="Scheduler job to invoke recommendation pipeline" \
  --oidc-service-account-email="recommender-scheduler-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com" \
  --headers="Content-Type=application/json" \
  --http-method="POST"

    Define la zona horaria para que coincida con la de tu ubicación. El formato del valor de la zona horaria se basa en la base de datos tz.

    Para obtener más información, consulta gcloud scheduler jobs create http.

    Tu tarea de Cloud Scheduler invoca la ruta /run del servicio recommendation-collector.

    Al definir la marca --schedule="0 */3 * * *", se ejecuta el trabajo de Scheduler cada tres horas. Puedes cambiar este ajuste según tus necesidades. Para obtener más información, consulta Configurar programaciones de tareas cron.

Crea el motor de reglas de recomendaciones para procesar las recomendaciones

En esta sección, crearás un segundo servicio de Cloud Run llamado recommendation-rules-engine para procesar las recomendaciones que recoge el servicio recommendation-collector. Pub/Sub invoca el servicio recommendation-rules-engine cuando se insertan nuevas recomendaciones en el tema activeassist-recommendations.

Este servicio analiza las recomendaciones en función de las reglas de negocio que haya definido en la colección activeassist-business-rules.

  1. En Cloud Shell, abre el directorio recommendation-rules-engine:

    cd ../recommendation-rules-engine

  2. Crea una variable de entorno para tu imagen Docker:

    export RULES_ENGINE_IMAGE=gcr.io/$RECO_MGR_PROJECT/recommendation-rules-engine:1.0

  3. Crea la imagen Docker y súbela a Container Registry:

    gcloud builds submit --tag $RULES_ENGINE_IMAGE

  4. Crea una cuenta de servicio para que el servicio recommendation-rules-engine interactúe con otros servicios de la canalización: Google Cloud 

    gcloud iam service-accounts create recommendation-rules-sa \
 --description "Service Account that recommendation-rules-engine uses to invoke other Google Cloud services" \
 --display-name "recommendation-rules-sa" \
 --project $RECO_MGR_PROJECT

  5. Da acceso a Firestore a la cuenta de servicio del servicio recommendation-rules-engine:

    gcloud projects add-iam-policy-binding $RECO_MGR_PROJECT \
  --member serviceAccount:recommendation-rules-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/datastore.user

    Si estás usando los stubs proporcionados en este tutorial, ve al siguiente paso.

    Si vas a probar la canalización con recomendaciones generadas para unGoogle Cloud proyecto en lugar de los stubs proporcionados en este tutorial, ejecuta los siguientes comandos para permitir que la cuenta de servicio del motor de reglas acceda a tu proyecto:

    gcloud projects add-iam-policy-binding $TEST_PROJECT_ID \
  --member serviceAccount:recommendation-rules-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/serviceusage.serviceUsageConsumer
gcloud projects add-iam-policy-binding $TEST_PROJECT_ID \
  --member serviceAccount:recommendation-rules-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/recommender.iamAdmin
gcloud projects add-iam-policy-binding $TEST_PROJECT_ID \
  --member serviceAccount:recommendation-rules-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/resourcemanager.projectIamAdmin

  6. Despliega el servicio de Cloud Run:

    gcloud run deploy recommendation-rules-engine \
  --image=$RULES_ENGINE_IMAGE \
  --no-allow-unauthenticated \
  --region $REGION \
  --platform managed \
  --service-account recommendation-rules-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --project $RECO_MGR_PROJECT

    Acepta las peticiones del sistema.

  7. Obtén la URL recommendation-rules-engine:

    export RECOMMENDER_SERVICE_RULES_URI=`gcloud run services describe recommendation-rules-engine \
  --platform managed \
  --project $RECO_MGR_PROJECT \
  --region $REGION \
  --format="value(status.url)"`/process

    La URL que obtienes en este paso se invoca cuando hay nuevas recomendaciones disponibles en el tema de Pub/Sub que creas en el siguiente paso.

Crear un tema de Pub/Sub para recomendaciones activas

En esta sección, crearás un tema de Pub/Sub para las recomendaciones de Active Assist que el servicio recommender-collector obtiene invocando la API Recommender.

  1. En Cloud Shell, crea un tema de Pub/Sub:

    gcloud pubsub topics create activeassist-recommendations

  2. Crea una cuenta de servicio para que Pub/Sub la use para invocar el servicio de recommendation-rules-engine Cloud Run:

    gcloud iam service-accounts create recommendation-engine-sub-sa \
  --description "Service Account used by Pub/Sub to push recommendations to the recommendation-rules-engine service" \
  --display-name "recommendation-engine-sub-sa" \
  --project $RECO_MGR_PROJECT

  3. La cuenta de servicio de Pub/Sub debe estar asociada a los roles que necesita para publicar mensajes e invocar el servicio recommendation-rules-engine:

    gcloud projects add-iam-policy-binding $RECO_MGR_PROJECT \
  --member serviceAccount:recommendation-engine-sub-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/run.invoker \
  --project $RECO_MGR_PROJECT

Crear una suscripción al tema de Pub/Sub

  1. Crea una suscripción al servicio recommendation-rules-engine:

    # grant Pub/Sub the permission to create tokens
PUBSUB_SERVICE_ACCOUNT="service-$RECO_MGR_PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com"
gcloud projects add-iam-policy-binding $RECO_MGR_PROJECT \
  --member="serviceAccount:$PUBSUB_SERVICE_ACCOUNT"\
  --role='roles/iam.serviceAccountTokenCreator'
# configure the subscription push identity
gcloud pubsub subscriptions create active-assist-recommendations-for-rules-engine \
  --topic=activeassist-recommendations \
  --topic-project=$RECO_MGR_PROJECT \
  --push-auth-service-account=recommendation-engine-sub-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --ack-deadline=60 \
  --push-endpoint=$RECOMMENDER_SERVICE_RULES_URI

  2. Permite que la cuenta de servicio recommendation-engine-sub-sa que has creado invoque el servicio recommendation-rules-engine:

    gcloud run services add-iam-policy-binding recommendation-rules-engine \
  --member=serviceAccount:recommendation-engine-sub-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role=roles/run.invoker \
  --region=$REGION \
  --platform=managed

Ejecutar pruebas integrales con stubs

La plataforma genera las recomendaciones de Active Assist en función de los patrones de uso y las métricas del sistema. Cada categoría de recomendación puede usar un periodo predeterminado diferente del pasado para analizar los datos de uso y las métricas en función de los cuales se generan las recomendaciones. Por ejemplo, la plataforma genera recomendaciones de IAM en función de los patrones de uso de los últimos 90 días.

Para probar la canalización completa, el repositorio que has clonado para este tutorial proporciona recomendaciones de ejemplo (stubs) que puedes usar para ejecutar la canalización completa.

En esta sección, harás lo siguiente:

  • Inspecciona las recomendaciones de stubs.
  • Invoca la canalización manualmente.
  • Comprueba si se genera una notificación y se envía al canal de Slack que has creado.

  1. Revisa las recomendaciones de ejemplo que se proporcionan en el repositorio:

    cat ../recommendation-collector/stub.json

    Este archivo proporciona una recomendación de ejemplo con una acción REMOVE para un rol de ejemplo llamado roles/gkehub.connect.

  2. Ejecuta el siguiente comando para que Cloud Scheduler ejecute la tarea inmediatamente, en lugar de esperar a la siguiente ejecución programada:

    gcloud scheduler jobs run recommender-iam-scheduler

  3. En la página de la consola Cloud Scheduler, en la columna Resultado de la tarea recommender-iam-scheduler, comprueba que el resultado sea Éxito.

    Para ver una vista detallada de los pasos que ejecuta cada servicio, también puedes consultar los registros de servicio de Cloud Run del servicio recommendation-collector y del servicio recommendation-rules-engine.

  4. Cuando se ejecute correctamente la canalización integral sin servidor que crees en este tutorial, se generará una notificación de Slack que contendrá los detalles de la vinculación de roles recomendada para que la elimines. A continuación, se muestra un ejemplo de la notificación que recibes:

    Project xxxxxxxx\
**Impact**: SECURITY\
This role has not been used during the observation window.\
**Role**: roles/gkehub.connect\
**Member**:
serviceAccount:sample-sa@recommendation-sample.iam.gserviceaccount.com\
**Action**: remove

Limpieza

Para evitar que los recursos utilizados en este tutorial se cobren en tu cuenta de Google Cloud, elimina el proyecto que contiene los recursos o conserva el proyecto y elimina los recursos.

  • In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  • In the project list, select the project that you want to delete, and then click Delete.
  • In the dialog, type the project ID, and then click Shut down to delete the project.

    • Siguientes pasos