Optimiza el uso de recursos en un clúster de GKE de instancias múltiples con aprovisionamiento automático de nodos

En este instructivo, se muestra cómo usar el aprovisionamiento automático de nodos para escalar un clúster multiusuario de Google Kubernetes Engine (GKE) y cómo usar Workload Identity para controlar el acceso de los usuarios a recursos como los depósitos de Cloud Storage. Esta guía es para desarrolladores y arquitectos, y se da por sentado que tienes conocimientos básicos de Kubernetes y GKE. Si necesitas una introducción, consulta Descripción general de GKE.

Por lo general, el clúster multiusuario se implementa a fin de reducir costos o estandarizar las operaciones para los usuarios. A fin de obtener un ahorro total de costos, debes dimensionar tu clúster para que los recursos del clúster se usen de manera eficiente. También debes minimizar el desperdicio de recursos cuando el clúster escala automáticamente. Para ello, asegúrate de que los nodos del clúster que se agregan tengan un tamaño adecuado.

En este instructivo, usarás el aprovisionamiento automático de nodos para escalar el clúster. El aprovisionamiento automático de nodos agrega nodos del clúster que se adaptan mejor a tus cargas de trabajo pendientes para optimizar el uso de recursos de tu clúster y, por lo tanto, controlar tus costos.

Objetivos

  • Crea un clúster de GKE que tenga habilitado el aprovisionamiento automático de nodos y Workload Identity.
  • Configura el clúster multiusuario.
  • Envía trabajos al clúster para demostrar cómo el aprovisionamiento automático de nodos crea y destruye nodos con tamaños optimizados.
  • Usa taints y etiquetas a fin de indicar al aprovisionamiento automático de nodos que cree grupos de nodos exclusivos para cada usuario.
  • Usa Workload Identity para controlar el acceso a los recursos específicos de los usuarios, como los depósitos de Cloud Storage.

Costos

En este instructivo, se usan 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 sean aptos para obtener una prueba gratuita.

Antes de comenzar

  1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
  2. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  3. Comprueba que la facturación esté habilitada en tu proyecto.

    Descubre cómo puedes habilitar la facturación

  4. En Cloud Console, activa Cloud Shell.

    Activar Cloud Shell

    En la parte inferior de Cloud Console, se inicia una sesión de Cloud Shell en la que se muestra una ventana de línea de comandos. Cloud Shell es un entorno de shell que tiene el SDK de Cloud preinstalado, incluida la herramienta de línea de comandos de gcloud, y valores ya establecidos para el proyecto actual. La inicialización de la sesión puede tomar unos minutos.

  5. En Cloud Shell, habilita las API para GKE y la API de Cloud Build:
    gcloud services enable container.googleapis.com \
        cloudbuild.googleapis.com
    

    Esta operación puede tardar unos minutos:

Prepara tu entorno

En esta sección, obtendrás el código que necesitas para este instructivo y configurarás tu entorno con valores que usarás durante todo el instructivo.

  1. En Cloud Shell, define las variables de entorno que usas para este instructivo:

    export PROJECT_ID=$(gcloud config get-value project)
    
  2. Clona el repositorio de GitHub que contiene el código para este instructivo:

    git clone https://github.com/GoogleCloudPlatform/solutions-gke-autoprovisioning
    
  3. Cambie al directorio del repositorio:

    cd solutions-gke-autoprovisioning
    
  4. Actualiza el archivo de configuración de trabajos YAML de Kubernetes con el ID del proyecto de Google:

    sed -i "s/MY_PROJECT/$PROJECT_ID/" manifests/bases/job/base-job.yaml
    
  5. Envía un trabajo de Cloud Build para compilar una imagen de contenedor:

    gcloud builds submit pi/ --tag gcr.io/$PROJECT_ID/generate-pi
    

    La imagen es un programa de Go que genera una aproximación de pi. Usarás esta imagen de contenedor más adelante.

    Cloud Build exporta la imagen al Container Registry de tu proyecto.

Crea un clúster de GKE

En esta sección, crearás un clúster de GKE que tenga habilitado el aprovisionamiento automático de nodos y Workload Identity. Ten en cuenta los siguientes detalles del proceso de creación del clúster:

  • Especifica los límites de CPU y memoria para el clúster. El aprovisionamiento automático de nodos respeta estos límites cuando agrega o quita nodos del clúster. Para obtener más información, consulta Habilita el aprovisionamiento automático de nodos en la documentación de GKE.
  • Especifica la cuenta de servicio predeterminada y los permisos que usarán los nodos dentro de los grupos de nodos aprovisionados automáticamente. Con esta configuración, podrás controlar los permisos de acceso del nodo aprovisionado. Si quieres obtener más información, consulta Configura los valores predeterminados de identidad para nodos aprovisionados de forma automática en la documentación de GKE.
  • Debes configurar un perfil de ajuste de escala automático que priorice el uso. Este perfil le indica al escalador automático del clúster que reduzca rápidamente la escala del clúster de manera vertical para minimizar los recursos no utilizados. Esto puede ayudar con la eficiencia de los recursos para cargas de trabajo centradas en los lotes o en los trabajos. La configuración se aplica a todos los grupos de nodos del clúster.
  • Para habilitar Workload Identity, especifica el grupo de cargas de trabajo.

Para ello, sigue estos pasos:

  1. Crea una cuenta de servicio:

    gcloud iam service-accounts create nap-sa
    

    Los nodos aprovisionados de forma automática usan esta cuenta de servicio.

  2. Otorga permisos a la cuenta de servicio nueva para extraer imágenes del bucket de Cloud Storage que usa Container Registry:

    gsutil iam ch \
        serviceAccount:nap-sa@$PROJECT_ID.iam.gserviceaccount.com:objectViewer \
        gs://artifacts.$PROJECT_ID.appspot.com
    
  3. Crea un clúster de GKE que tenga habilitado el aprovisionamiento automático de nodos y Workload Identity.

    gcloud container clusters create multitenant \
        --release-channel=regular \
        --zone=us-central1-c \
        --num-nodes=2 \
        --machine-type=n1-standard-2 \
        --workload-pool=${PROJECT_ID}.svc.id.goog \
        --autoscaling-profile=optimize-utilization \
        --enable-autoprovisioning \
        --autoprovisioning-service-account=nap-sa@${PROJECT_ID}.iam.gserviceaccount.com \
        --autoprovisioning-scopes=\
    https://www.googleapis.com/auth/devstorage.read_write,\
    https://www.googleapis.com/auth/cloud-platform \
        --min-cpu 1 \
        --min-memory 1 \
        --max-cpu 50 \
        --max-memory 256 \
        --enable-network-policy \
        --enable-ip-alias
    
  4. Establece el nombre y la zona de procesamiento del clúster predeterminado:

    gcloud config set container/cluster multitenant
    gcloud config set compute/zone us-central1-c
    

Configura el clúster multiusuario

Cuando operas una aplicación multiusuario de software como servicio (SaaS), por lo general, debes separar a tus usuarios. Separarlos puede ayudar a minimizar los daños de un usuario vulnerado. También puede ayudarte a asignar recursos de clúster de manera uniforme entre usuarios y realizar un seguimiento de cuántos recursos consume cada uno. Kubernetes no puede garantizar un aislamiento del todo seguro entre los usuarios, pero ofrece características que pueden ser suficientes para casos de uso específicos. Para obtener más información sobre las características de multiusuario de GKE, consulta las guías de descripción general y prácticas recomendadas en la documentación de GKE.

En la app de ejemplo, debes crear dos usuarios, tenant1 y tenant2. Separa cada usuario y sus recursos de Kubernetes en su propio espacio de nombres. Debes crear una política de red simple que impida la comunicación de otros espacios de nombres para imponer el aislamiento de los usuarios. Después, debes usar campos de taints de nodo y nodeSelector para evitar que los pods de los distintos usuarios se programen en el mismo nodo. Puedes proporcionar un grado adicional de separación mediante la ejecución de cargas de trabajo de usuario en nodos exclusivos.

Debes usar Kustomize para administrar los manifiestos de Kubernetes que envías al clúster. Kustomize te permite combinar y personalizar los archivos YAML para varios propósitos.

  1. Crea un espacio de nombres, una cuenta de servicio y un recurso de política de red para tenant1:

    kubectl apply -k manifests/setup/tenant1
    

    El resultado será similar a esto:

    namespace/tenant1-ns created
    serviceaccount/tenant1-ksa created
    networkpolicy.networking.k8s.io/tenant1-deny-from-other-namespaces created
    
  2. Crea los recursos del clúster para tenant2:

    kubectl apply -k manifests/setup/tenant2
    

Verifica el comportamiento del aprovisionamiento automático de nodos

Un clúster de GKE consta de uno o más grupos de nodos. Todos los nodos dentro de un grupo de nodos tienen el mismo tipo de máquina, lo que significa que tienen la misma cantidad de CPU y memoria. Si tus demandas de recursos de cargas de trabajo son variables, te servirá tener varios grupos de nodos con diferentes tipos de máquinas dentro de tu clúster. De esta manera, el escalador automático del clúster podrá agregar nodos del tipo más adecuado, lo que puede mejorar la eficiencia de tus recursos y, por lo tanto, reducir los costos. Sin embargo, mantener muchos grupos de nodos agrega sobrecarga de administración. Puede que no sea práctico en un clúster multiusuario si deseas ejecutar cargas de trabajo de usuarios en grupos de nodos dedicados.

En su lugar, puedes usar el aprovisionamiento automático de nodos para extender el escalador automático del clúster. Cuando el aprovisionamiento automático de nodos está habilitado, el escalador automático del clúster puede crear grupos de nodos nuevos de forma automática en función de las especificaciones de pods pendientes. Como resultado, el escalador automático del clúster puede crear nodos del tipo más adecuado, y no necesitarás crear ni administrar los grupos de nodos por tu cuenta. Con el aprovisionamiento automático de nodos, tu clúster puede realizar un ajuste de escala automático de forma eficiente sin aprovisionamiento en exceso, lo que puede ayudarte a reducir tus costos.

Además, si los pods pendientes tienen restricciones a la separación de cargas de trabajo, el aprovisionamiento automático puede crear nodos que cumplan con las restricciones. De esta manera, podrás usar el aprovisionamiento automático para crear de forma automática grupos de nodos que solo un usuario usará.

En esta sección, enviarás varios trabajos al clúster para verificar el comportamiento del aprovisionamiento automático de nodos. Los trabajos usan la imagen generate-pi que creaste antes.

Envía un trabajo simple

Primero, envía un trabajo simple al clúster. El trabajo no tiene ninguna restricción específica de usuario. Hay suficiente capacidad libre en el clúster para manejar las solicitudes de CPU y memoria del trabajo. Por lo tanto, el trabajo se programará en uno de los nodos existentes en el grupo de nodos predeterminado. No se aprovisionan nodos adicionales.

  1. Enumera los grupos de nodos del clúster:

    gcloud container node-pools list
    

    Verás un solo grupo predeterminado.

  2. Imprime la configuración del trabajo en la consola:

    kubectl kustomize manifests/jobs/simple-job/
    

    El resultado será similar a esto:

    apiVersion: batch/v1
    kind: Job
    metadata:
    name: pi-job
    spec:
    ...
    

    La configuración no especifica ningún taint o selector de los nodos.

  3. Envía el trabajo:

    kubectl apply -k manifests/jobs/simple-job/
    
  4. Mira los grupos de nodos del clúster:

    watch -n 5 gcloud container node-pools list
    

    Seguirás viendo un solo grupo predeterminado. No se crearán grupos de nodos nuevos.

  5. Después de unos 30 segundos, presiona Control+C para dejar de ver los grupos de nodos.

  6. Observa los nodos en el clúster:

    kubectl get nodes -w
    

    No verás ningún nodo nuevo que se esté creando.

  7. Después de mirar durante 1 minuto, presiona Control+C para dejar de ver.

  8. Enumera los trabajos del clúster:

    kubectl get jobs --all-namespaces
    

    El resultado será similar a esto:

    NAMESPACE   NAME     COMPLETIONS   DURATION   AGE
    default     pi-job   1/1           14s        21m
    

    El valor 1/1 de la columna Completions indica que se completó 1 trabajo de un total de 1.

Envía un trabajo que tenga restricciones específicas de usuario

En esta sección, enviarás otro trabajo para confirmar que el aprovisionamiento automático de nodos aplica las restricciones a la separación de cargas de trabajo. La configuración del trabajo incluye un selector de nodos específico de un usuario y una tolerancia específica de un usuario. El trabajo se puede programar solo en un nodo que tenga etiquetas que coincidan con los pares clave-valor del selector. Una tolerancia funciona junto con taints de nodo, que también limitan los trabajos que se pueden programar en un nodo. Una práctica recomendada para el aprovisionamiento automático de nodos consiste en incluir un selector de nodos y una tolerancia para la separación de cargas de trabajo.

Este trabajo no se puede programar en el grupo de nodos predeterminado, ya que ese grupo no tiene nodos que cumplan con la restricción del selector. Por lo tanto, el aprovisionamiento automático de nodos crea un nuevo grupo de nodos con etiquetas de nodo que satisfacen el requisito del selector. El aprovisionamiento automático de nodos también agrega un taint específico de usuario a los nodos que coinciden con la tolerancia en la configuración del trabajo. Solo los pods con una tolerancia que coincida pueden programarse en los nodos del grupo, lo que te permite separar aún más las cargas de trabajo de los usuarios.

  1. Enumera los grupos de nodos del clúster:

    gcloud container node-pools list
    

    Verás un solo grupo predeterminado.

  2. Imprime la configuración del trabajo en la consola:

    kubectl kustomize manifests/jobs/one-tenant/
    

    La configuración incluye un requisito de selector de nodos específico del usuario y una tolerancia. El resultado luce de la siguiente manera:

    apiVersion: batch/v1
    kind: Job
    metadata:
    name: tenant1-pi-job
    spec:
    ...
    
  3. Envía el trabajo:

    kubectl apply -k manifests/jobs/one-tenant/
    
  4. Mira los grupos de nodos del clúster:

    watch -n 5 gcloud container node-pools list
    

    Después de un tiempo, verás un nuevo grupo de nodos. El resultado será similar a esto:

    NAME                            MACHINE_TYPE       DISK_SIZE_GB
    default-pool                    n1-standard-2      100
    nap-n1-standard-1-15jwludl      n1-standard-1      100
    

    El nombre del grupo de nodos tiene el prefijo nap-, que indica que se creó con el aprovisionamiento automático de nodos. El nombre del grupo de nodos también incluye el tipo de máquina de los nodos del grupo, por ejemplo, n1-standard-1.

  5. Observa los nodos en el clúster:

    kubectl get nodes -w
    

    Después de un minuto, aparecerá un nodo nuevo en la lista. El nombre del nodo incluirá el nombre del grupo de nodos nap-. El nodo nuevo inicialmente tendrá un estado Not Ready. Después de un tiempo, el estado del nodo nuevo cambiará a Ready, lo que significa que el nodo ahora puede aceptar trabajos pendientes.

  6. Para dejar de ver los nodos, presiona Control+C.

  7. Enumera los taints de nodo:

    kubectl get nodes -o custom-columns=NAME:.metadata.name,TAINTS:.spec.taints
    

    Verás que el nodo nuevo tiene un taint NoSchedule para el par clave-valor tenant: tenant1. Por lo tanto, solo los pods que tienen una tolerancia correspondiente para tenant: tenant1 se podrán programar en el nodo.

  8. Mira los trabajos en el clúster:

    kubectl get jobs -w --all-namespaces
    

    Después de un tiempo, verás que tenant1-pi-job tiene una finalización de 1/1, lo que indica que terminó con éxito.

  9. Para dejar de ver los trabajos, presiona Control+C.

  10. Mira los grupos de nodos del clúster:

    watch -n 5 gcloud container node-pools list
    

    Después de un tiempo, verás que se borrará el grupo nap- y que el clúster volverá a tener el solo grupo de nodos predeterminado. El aprovisionamiento automático de nodos borró el grupo de nodos nap-, porque no hay más trabajos pendientes que coincidan con las restricciones del grupo.

  11. Para dejar de ver los grupos de nodos, presiona Control+C.

Envía dos trabajos más grandes con restricciones de usuarios.

En esta sección, enviarás dos trabajos que tienen restricciones específicas de usuarios y, también, aumentarás las solicitudes de recursos para cada trabajo. Una vez más, estos trabajos no se pueden programar en el grupo de nodos predeterminado debido a las restricciones del selector de nodos. Debido a que cada trabajo tiene su propia restricción de selector, el aprovisionamiento automático de nodos creará dos grupos de nodos nuevos. De esta manera, podrás usar el aprovisionamiento automático de nodos para mantener separados los trabajos de los usuarios. Debido a que los trabajos tienen una mayor cantidad de solicitudes de recursos en comparación con el trabajo anterior, el aprovisionamiento automático de nodos creará grupos de nodos que tendrán tipos de máquinas más grandes que los anteriores.

  1. Enumera los grupos de nodos del clúster:

    gcloud container node-pools list
    

    Verás un solo grupo predeterminado.

  2. Imprime la configuración combinada:

    kubectl kustomize manifests/jobs/two-tenants/
    

    La configuración incluye dos trabajos separados, cada uno con un selector de nodos y una tolerancia específicos de usuarios, y un aumento de las solicitudes de recursos.

    El resultado será similar a esto:

    apiVersion: batch/v1
    kind: Job
    metadata:
    name: tenant1-larger-pi-job
    spec:
    ...
    
  3. Envía los trabajos:

    kubectl apply -k manifests/jobs/two-tenants/
    
  4. Mira los grupos de nodos del clúster:

    watch -n 5 gcloud container node-pools list
    

    Después de un tiempo, verás dos grupos de nodos adicionales. El resultado luce de la siguiente manera:

    NAME                            MACHINE_TYPE       DISK_SIZE_GB
    default-pool                    n1-standard-2      100
    nap-n1-standard-2-6jxjqobt      n1-standard-2      100
    nap-n1-standard-2-z3s06luj      n1-standard-2      100
    

    Los nombres de los grupos de nodos tienen el prefijo nap-, que indica que se crearon mediante el aprovisionamiento automático de nodos. Los nombres de los grupos de nodos también incluyen el tipo de máquina de los nodos del grupo, por ejemplo, n1-standard-2.

  5. Para dejar de ver los nodos, presiona Control+C.

  6. Observa los nodos en el clúster:

    kubectl get nodes -w
    

    Después de un minuto, aparecerán dos nodos nuevos en la lista. Los nombres de los nodos incluirán el nombre de su grupo de nodos nap- asociado. Los nodos nuevos inicialmente tienen un estado Not Ready. Después de un tiempo, el estado de los nodos nuevos cambiará a Ready, lo que significa que los nodos ahora pueden aceptar trabajos pendientes.

  7. Para dejar de ver los nodos, presiona Control+C.

  8. Enumera los taints de nodo:

    kubectl get nodes -o custom-columns=NAME:.metadata.name,TAINTS:.spec.taints
    

    Verás que los nodos nuevos tendrán taints NoSchedule, uno con el par clave-valor tenant: tenant1 y el otro con tenant: tenant2. Solo los se pueden programar en los nodos los pods que tienen tolerancias de usuario correspondientes.

  9. Mira los trabajos en el clúster:

    kubectl get jobs -w --all-namespaces
    

    Después de un tiempo, verás que tenant1-larger-pi-job y tenant2-larger-pi-job cambian para que 1/1 se complete en cada uno, lo que indica que los trabajos finalizaron de forma correcta.

  10. Para dejar de ver los trabajos, presiona Control+C.

  11. Mira los grupos de nodos del clúster:

    watch -n 5 gcloud container node-pools list
    

    Después de un tiempo, verás que se borraron ambos grupos nap- y que el clúster vuelve a tener un solo grupo de nodos predeterminado. El aprovisionamiento automático de nodos borró los grupos de nodos nap-, porque no hay más trabajos pendientes que coincidan con las restricciones de los grupos.

  12. Para dejar de ver los grupos de nodos, presiona Control+C.

Controla el acceso a los recursos de Google Cloud

Además de mantener la separación de usuarios dentro del clúster, es posible que también desees controlar el acceso de las instancias a los recursos de Google Cloud, como los depósitos de Cloud Storage o los temas de Pub/Sub. Por ejemplo, cada usuario puede requerir un bucket de Cloud Storage al que otros usuarios no deberían poder acceder.

Con Workload Identity, puedes crear una asignación entre las cuentas de servicio de Kubernetes y las cuentas de servicio de Google Cloud. Luego, puedes asignar las funciones adecuadas de Identity and Access Management (IAM) a la cuenta de servicio de Google Cloud. De esta manera, podrás aplicar el principio de privilegio mínimo para que los trabajos de usuario puedan acceder a sus recursos asignados, pero se les impedirá acceder a los recursos que son propiedad de otros usuarios.

Configura la identidad de la carga de trabajo de GKE

Configura la asignación entre tu cuenta de servicio de Kubernetes y una cuenta de servicio de Google Cloud que crees.

  1. Crea una cuenta de servicio de Google Cloud para tenant1:

    gcloud iam service-accounts create tenant1-gsa
    
  2. Otorga a la cuenta de servicio de Kubernetes los permisos de IAM de tenant1 para que use la cuenta de servicio de Google Cloud de tenant1 correspondiente:

    gcloud iam service-accounts add-iam-policy-binding \
        tenant1-gsa@${PROJECT_ID}.iam.gserviceaccount.com \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:${PROJECT_ID}.svc.id.goog[tenant1-ns/tenant1-ksa]"
    
  3. A fin de completar la asignación entre las cuentas de servicio, anota la cuenta de servicio de Kubernetes con la cuenta de servicio de Google Cloud:

    kubectl annotate serviceaccount tenant1-ksa -n tenant1-ns \
        iam.gke.io/gcp-service-account=tenant1-gsa@${PROJECT_ID}.iam.gserviceaccount.com
    

Envía un trabajo que escriba en un bucket de Cloud Storage

En esta sección, confirmarás que un trabajo que se ejecuta como una cuenta de servicio de Kubernetes pueda usar los permisos de IAM de su cuenta de servicio de Google Cloud asignada.

  1. Crea un bucket de Cloud Storage nuevo para tenant1.

    export BUCKET=tenant1-$PROJECT_ID
    gsutil mb -b on -l us-central1 gs://$BUCKET
    

    Usa el ID de tu proyecto como sufijo del nombre del depósito a fin de que sea único.

  2. Actualiza el archivo de configuración del trabajo para usar el depósito de Cloud Storage:

    sed -i "s/MY_BUCKET/$BUCKET/" \
        manifests/jobs/write-gcs/bucket-write.yaml
    
  3. Otorga los permisos de la cuenta de servicio de tenant1 para leer y escribir objetos en el depósito:

    gsutil iam ch \
        serviceAccount:tenant1-gsa@$PROJECT_ID.iam.gserviceaccount.com:objectAdmin \
        gs://$BUCKET
    
  4. Imprime la configuración del trabajo:

    kubectl kustomize manifests/jobs/write-gcs/
    

    El resultado será similar a esto:

    apiVersion: batch/v1
    kind: Job
    metadata:
    name: tenant1-pi-job-gcs
    spec:
    ...
    

    El nombre del bucket nuevo se pasa como argumento al contenedor generate-pi, y el trabajo especifica la cuenta de servicio tenant1-ksa de Kubernetes adecuada.

  5. Envía el trabajo:

    kubectl apply -k manifests/jobs/write-gcs/
    

    Al igual que en la sección anterior, el aprovisionamiento automático de nodos crea un grupo de nodos nuevo y un nodo nuevo para ejecutar el trabajo.

  6. Mira el pod del trabajo:

    kubectl get pods -n tenant1-ns -w
    

    En este caso, mira el pod en lugar de mirar el grupo de nodos. Verás que el Pod pasa por distintos estados. Después de unos minutos, el estado cambiará a Completed. Este estado indica que el trabajo se completó de forma correcta.

  7. Para detener la reproducción, presiona Control+C.

  8. Confirma que se haya escrito un archivo en el bucket de Cloud Storage:

    gsutil ls -l gs://$BUCKET
    

    Verás un solo archivo.

  9. Para realizar la limpieza, borra el trabajo:

    kubectl delete job tenant1-pi-job-gcs -n tenant1-ns
    

    Volverás a enviar este trabajo en la siguiente sección.

Revoca permisos de IAM

Por último, confirma que revocar los permisos de IAM de la cuenta de servicio de Google Cloud evita que la cuenta de servicio de Kubernetes asignada acceda al depósito de Cloud Storage.

  1. Revoca los permisos de la cuenta de servicio de Google Cloud para escribir en el depósito de Cloud Storage:

    gsutil iam ch -d \
        serviceAccount:tenant1-gsa@$PROJECT_ID.iam.gserviceaccount.com:objectAdmin \
        gs://$BUCKET
    
  2. Envía el mismo trabajo que antes:

    kubectl apply -k manifests/jobs/write-gcs/
    
  3. Una vez más, vuelva a mirar el estado del pod del trabajo:

    kubectl get pods -n tenant1-ns -w
    

    Después de un par de minutos, el estado cambiará a Error, lo que indica que el trabajo falló. Este error es esperable, ya que el trabajo se ejecuta como una cuenta de servicio de Kubernetes que se asigna a una cuenta de servicio de Google Cloud que, a su vez, ya no tiene permisos de escritura en el depósito de Cloud Storage.

  4. Para dejar de ver el pod, presiona Control+C.

  5. Obtén una lista de los archivos en el depósito:

    gsutil ls -l gs://$BUCKET
    

    Verás un solo archivo en el bucket. No se escribió un archivo nuevo.

Limpia

La manera más fácil de eliminar la facturación es borrar el proyecto de Cloud que creaste para el instructivo.

Borra el proyecto

  1. En Cloud Console, ve a la página Administrar recursos.

    Ir a Administrar recursos

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

Borra el clúster de GKE

Si no quieres borrar el proyecto, borra el clúster de GKE:

gcloud container clusters delete multitenant

¿Qué sigue?