Usa canalizaciones sin servidores con Active Assist

Last reviewed 2021-06-09 UTC

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

En este instructivo, se muestra cómo usar las tecnologías sin servidores de Google Cloud para compilar una canalización de automatización a fin de recuperar y procesar recomendaciones de Active Assist. Las recomendaciones se basan en las reglas empresariales que establece tu empresa. La canalización de automatización que configuraste en este instructivo te ayuda a trabajar con Active Assist a gran escala y, a la vez, mantiene un proceso de revisión y activación liderado por el equipo. Este enfoque es útil cuando tu empresa desea escalar el uso de la cartera de Active Assist, pero mantener el control del proceso de revisión y activación dentro de los equipos. Ofrece una alternativa al uso de una canalización de integración y entrega continua (CI/CD).

La arquitectura que se muestra en este instructivo es genérica y puedes extenderla para que funcione con otros productos sin servidores. En el instructivo, se supone que estás familiarizado con las siguientes tecnologías de Google Cloud:

A fin de completar este instructivo, debes tener una cuenta para Slack o una notificación similar o una herramienta de procesamiento de tickets. La herramienta debe estar configurada en tu máquina y lista para que la uses.

Arquitectura

Debido a que la arquitectura que se muestra en este instructivo es modular, puedes adaptar el componente de notificaciones para que cumpla con los requisitos de tu empresa. En este instructivo, se muestra cómo generar notificaciones y enviarlas a Slack. También puedes elegir enviar notificaciones a Pub/Sub o a cualquier otra herramienta de notificación o procesamiento de tickets.

En el siguiente diagrama de arquitectura, se muestran los componentes que usas en este instructivo.

Canalización sin servidores

La arquitectura tiene los siguientes componentes:

  • Un servicio de Cloud Run que un programador activa en intervalos fijos El servicio invoca las API del recomendador mediante la lectura de los metadatos (ID del proyecto y tipos de recomendador) que se definen y mantienen en una colección de Firestore.
  • Un tema de Pub/Sub en el que se envían 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 empresariales definidas por tu empresa y cómo se almacenan en una colección de Firestore.
  • Dos colecciones de Firestore para almacenar los metadatos y las reglas empresariales. Las colecciones de Firestore operan de la siguiente manera:
    • La primera colección almacena los metadatos empresariales relevantes para recuperar las recomendaciones de Active Assist. En este instructivo, 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 recomendación se recuperan.
    • La segunda colección almacena las reglas empresariales que se aplican cuando se procesan las recomendaciones.

Objetivos

  • Crear un servicio de Cloud Run de muestra a fin de recuperar recomendaciones de Active Assist para un proyecto de muestra y enviarlos a un tema de Pub/Sub.
  • Crear dos colecciones de Firestore para almacenar metadatos de muestra y reglas empresariales respectivamente.
  • Crear un segundo servicio de Cloud Run para procesar las recomendaciones de acuerdo con las reglas empresariales de muestra que defines en este instructivo.
  • Crear un canal de Slack al que el servicio de Cloud Run envíe recomendaciones de muestra de Active Assist.
  • Probar la canalización de extremo a extremo con recomendaciones de Active Assist de muestra.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. Para obtener más información, consulta Cómo realizar una limpieza.

Antes de comenzar

  1. En la consola de Google Cloud, ve a la página del selector de proyectos.

    Ir al selector de proyectos

  2. Selecciona o crea un proyecto de Google Cloud.

  3. Toma nota del ID del proyecto de Google Cloud para el proyecto del administrador de recomendaciones. Necesitarás este ID en la siguiente sección para configurar tu entorno.

  4. Habilita las API de Cloud Build, Firestore, App Engine,Pub/Sub, Cloud Run, Cloud Scheduler y Cloud Source Repositories .

    Habilita las API

    En este instructivo, usarás las credenciales de aplicación predeterminadas. Si se te solicita que crees credenciales en la página Agregar credenciales a tu proyecto, haz clic en Cancelar.

  5. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

  6. Crea lo siguiente:
    • Un canal de Slack de muestra
    • Una app de Slack y un webhook entrante de muestra para recibir notificaciones generadas por un motor llamado recommendation-rules-engine. Más adelante en este instructivo, configurarás el motor.
    Para obtener más información, consulta Create a Slack channel y Sending messages using Incoming Webhooks.

    Cuando hayas creado una app de Slack y una URL de webhook entrante, toma nota de la URL, ya que la necesitarás más adelante en este instructivo.

Compila la canalización sin servidores

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

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

Crea las colecciones de Firestore

En esta sección, debes crear dos colecciones de Firestore. La primera, la colección activeassist-metadata, almacena los metadatos empresariales relevantes para recuperar las recomendaciones de Active Assist. En segundo lugar, la colección activeassist-business-rules almacena las reglas empresariales que se aplican cuando la canalización procesa las recomendaciones.

Cuando se analizan las recomendaciones de Active Assist, se basan en las reglas empresariales de la colección de Firestore, se genera y se envía una notificación o se aplica de forma automática al recurso relevante de Google Cloud.

Crea la colección activeassist-metadata

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

    Abrir Firestore

  2. Crea una base de datos de Firestore si aún no la tienes. Como alternativa, 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 ubicación de región cercana a la región en la que se ejecutan los servicios de Cloud Run.
    3. Haga clic en Crear base de datos. La configuración toma unos minutos.

  3. En la página de Firestore, haz clic en Iniciar colección.

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

  5. Propaga los campos como se muestra en la tabla siguiente. Para agregar el siguiente campo, haz clic en Agregar campo.

    Nombre del campo Tipo de campo Valor del campo Nota
    project string Stub-Project-ID En este instructivo, se usa un stub para el valor del campo. Si quieres usar recomendaciones de un proyecto de Google Cloud existente, ingresa el ID del proyecto.
    locations array global Algunas recomendaciones pueden ser específicas de la región o zona, como las de redimensionamiento de VM. Otras recomendaciones son globales, por ejemplo, las recomendaciones de IAM.
    recommenderType string google.iam.policy.Recommender No aplicable

  6. Cuando se propaguen 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, ingresa lo siguiente: activeassist-business-rules

    Propague el documento, como se muestra en la siguiente tabla. Para agregar el siguiente campo, haz clic en Agregar campo.

    Nombre del campo Tipo de campo Valor del campo Nota
    action string Notify Establecer el valor en Apply hace que el servicio aplique la recomendación y quite la función que no se usa.
    projectId string Stub-Project-ID En este instructivo, se usa una recomendación de stub. Si quieres usar recomendaciones de un proyecto de Google Cloud existente, ingresa el ID del proyecto.
    projectNumber string 999999999 En este instructivo, se usa una recomendación de stub.

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

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

    En este instructivo, se muestra cómo construir una regla para determinar si una recomendación se aplica de forma automática o si se genera una notificación y se envía a una plataforma como Slack. Para obtener información sobre cómo se puede aplicar una recomendación de forma automática según la evaluación de las reglas empresariales de muestra que configuraste, consulta el repositorio asociado.

  3. Cuando se complete el documento, haz clic en Guardar.

Crea un servicio programado de Cloud Run

En esta sección, crearás un servicio programado de Cloud Run llamado recommendation-collector que invoca la API del recomendador y recupera recomendaciones activas. En este instructivo, se usa la API del Recomendador de la Identity and Access Management como la API de Recommender. El servicio lee los metadatos de la colección de Firestore activeassist-metadata que creaste para determinar qué recomendaciones recuperar.

  1. Haz clic en Abrir en Cloud Shell a fin de abrir Cloud Shell para el proyecto del administrador de recomendaciones.

    Abrir en Cloud Shell

    Cuando se abre Cloud Shell, se ejecutan los siguientes comandos:

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

  2. Establece el ID y el número del proyecto de administrador de recomendaciones 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)')

    Reemplaza PROJECT_ID con el ID del proyecto. Una vez que hayas ingresado los comandos, haz clic en Autorizar cuando se te solicite.

  3. Establece una variable para la región de implementación:

    export REGION=us-central1

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

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

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

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

     gcloud builds submit --tag $RECOMMENDER_IMAGE

  6. Crea una cuenta de servicio para el servicio recommendation-collector a fin de interactuar con otros servicios de Google Cloud en la canalización:

    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

    Se recomienda otorgar funciones predefinidas a la cuenta de servicio para otorgar permisos detallados a tus servicios de Cloud Run. Para obtener más información, consulta Identidad del servicio.

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

    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 ejecutas este instructivo mediante el stub de muestra que se proporciona en el repositorio que clonaste, pasa al siguiente paso.

    Si compilas la canalización en este instructivo mediante recomendaciones generadas para un proyecto de Google Cloud existente, debes asignar permisos de IAM a las cuentas de servicio que creaste a fin de ejecutar los dos servicios de Cloud Run.

    Configura una variable de entorno, TEST_PROJECT_ID, con el ID del proyecto en el que ejecutaste 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 del proyecto que uses coincida con el que ingresaste en Crea las colecciones de Firestore.

  9. Para este instructivo, implementarás el servicio con una variable de entorno llamada STUB_RECOMMENDATIONS. Esta variable te permite usar un stub para probar la canalización.

    Implementa 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 solicitudes del sistema.

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

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

Configura un trabajo de Cloud Scheduler para ejecutar el recommender-collector service

  1. En Cloud Shell, crea una cuenta de servicio para los trabajos de Cloud Scheduler que se usarán a fin de 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. Otorga a la cuenta de servicio la función run/invoker para permitir que invoque al 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 de 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 un trabajo de Cloud Scheduler llamado 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"

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

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

    Tu trabajo de Cloud Scheduler invoca la ruta /run para el servicio recommendation-collector.

    Si configuras la marca --schedule="0 */3 * * *", se ejecuta el trabajo de programador cada tres horas. Puedes cambiar esta configuración según tus requisitos. Para obtener más información, consulta Configura programas de trabajos 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 recopila el servicio recommendation-collector. Pub/Sub invoca el servicio recommendation-rules-engine cuando se envían recomendaciones nuevas al tema activeassist-recommendations.

Este servicio analiza las recomendaciones en función de las reglas empresariales que definiste 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 de Docker:

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

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

    gcloud builds submit --tag $RULES_ENGINE_IMAGE

  4. Crea una cuenta de servicio para el servicio recommendation-rules-engine a fin de interactuar con otros servicios de Google Cloud en la canalización:

    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. Otorga a la cuenta de servicio del servicio recommendation-rules-engine el acceso a Firestore:

    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 usas los stubs que se proporcionan para este instructivo, continúa con el siguiente paso.

    Si pruebas la canalización con recomendaciones generadas para un proyecto de Google Cloud en lugar de los stubs que se proporcionan en este instructivo, ejecuta los siguientes comandos a fin de 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. Implementa 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 solicitudes 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 recuperas en este paso se invoca cuando el tema de Pub/Sub que creas en el paso siguiente crea recomendaciones nuevas.

Crea un tema de Pub/Sub para las recomendaciones activas

En esta sección, crearás un tema de Pub/Sub para las recomendaciones de Active Assist que recupera el servicio recommender-collector mediante la invocación de la API del recomendador.

  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 a fin de invocar el servicio recommendation-rules-engine de 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 con las funciones que necesita para publicar mensajes y, luego, 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

Crea una suscripción para el tema de Pub/Sub

  1. Crea una suscripción para el 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 creaste 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

Ejecuta pruebas de extremo a extremo con stubs

La plataforma genera 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 una período de tiempo predeterminada diferente en el pasado para analizar datos de uso y métricas según las recomendaciones que se generan. Por ejemplo, la plataforma genera recomendaciones de IAM en función de patrones de uso de los últimos 90 días.

A fin de probar la canalización de extremo a extremo, el repositorio que clonaste para este instructivo proporciona recomendaciones de ejemplo (stubs) que usas a fin de ejecutar la canalización de extremo a extremo.

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

  • Inspeccionar las recomendaciones de stub.
  • Invocar la canalización de manera manual.
  • Comprobar si se genera una notificación y se envía al canal de Slack que creaste.

  1. Revisa las recomendaciones de muestra proporcionadas en el repositorio:

    cat ../recommendation-collector/stub.json

    Este archivo proporciona una recomendación de muestra con una acción REMOVE para una función de muestra llamada roles/gkehub.connect.

  2. Ejecuta el siguiente comando para obtener Cloud Scheduler de inmediato, 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 de Cloud Scheduler, en la columna Resultado (result) para el trabajo recommender-iam-scheduler, verifica que el resultado sea Correcto (correcto).

    A fin de obtener una vista detallada de los pasos que ejecuta cada uno de los servicios, también puedes ver los registros del servicio de Cloud Run para el servicio recommendation-collector y el recommendation-rules-engine.

  4. Cuando la canalización sin servidores de extremo a extremo que compilas en este instructivo se ejecuta de forma correcta, genera una notificación de Slack que contiene detalles de la vinculación de función recomendada para que la quites. A continuación, se incluye 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

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

  • En la consola de Google Cloud, ve a la página Administrar recursos.

    Ir a Administrar recursos

  • En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
  • En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

    • ¿Qué sigue?