Accede a clústeres privados de Google Kubernetes Engine desde grupos privados de Cloud Build con Identity Service para GKE

---

En este instructivo, se describe cómo acceder al plano de control de un clúster privado de Google Kubernetes Engine (GKE) mediante grupos privados de Cloud Build. Este acceso te permite usar Cloud Build para implementar aplicaciones y administrar recursos en un clúster privado de GKE. Este instructivo está dirigido a administradores de plataformas, administradores de clústeres y desarrolladores. Se supone que estás familiarizado con GKE, Cloud Build, OpenID Connect y la herramienta de línea de comandos de gcloud.

Los grupos privados de Cloud Build y los planos de control del clúster de GKE se ejecutan en redes de nube privada virtual (VPC) propiedad de Google. Estas redes de VPC intercambian tráfico con tu propia red de VPC en Google Cloud. Sin embargo, el intercambio de tráfico entre redes de VPC no admite el intercambio de tráfico transitivo, que puede ser una restricción cuando usas grupos privados de Cloud Build. En este instructivo, se presenta una solución que usa Identity Service para GKE para permitir que los trabajadores de un grupo privado de Cloud Build accedan al plano de control de un clúster privado de GKE.

Descripción general de la arquitectura

Identity Service para GKE es un proxy de autenticación para los planos de control de los clústeres de GKE. Envía las solicitudes al servidor de la API mediante proxy y valida los tokens de ID que emiten los proveedores de identidad de OpenID Connect (OIDC). Después de que el proxy valida correctamente un token de ID, agrega encabezados HTTP de suplantación de identidad del usuario a la solicitud original y la reenvía al servidor de la API. El proxy se ejecuta como una cuenta de servicio de Kubernetes que tiene permisos para actuar en nombre de usuarios y grupos.

El proxy de Identity Service para GKE se ejecuta como pods en los nodos del clúster. Un servicio de Kubernetes de tipo LoadBalancer expone el proxy fuera del clúster. Si Identity Service para GKE está habilitado en un clúster privado, el instalador agrega una anotación al servicio de Kubernetes para aprovisionar un balanceador de cargas de red de transferencia interno. Se puede acceder al proxy a través del balanceador de cargas mediante una conexión de intercambio de tráfico entre redes de VPC, como desde un grupo privado de Cloud Build, ya que el proxy se ejecuta en nodos de clúster en tu red de VPC.

Puedes configurar Google como proveedor de identidad de OpenID Connect en Identity Service para GKE porque el sistema de autenticación OAuth 2.0 de Google cumple con la especificación de OpenID Connect. Para obtener tokens de ID para una cuenta de servicio de Google, puedes usar el método generateIdToken de la API de Service Account Credentials. Google emite y firma los tokens de ID.

En conjunto, esta solución permite el acceso al plano de control privado del clúster de GKE mediante el proxy de Identity Service para GKE. Las compilaciones que se ejecutan en un grupo privado de Cloud Build se conectan al proxy a través de una conexión de intercambio de tráfico entre redes de VPC. La compilación que se ejecuta en el grupo privado de Cloud Build se ejecuta como una cuenta de servicio de Google. Esta cuenta de servicio de Google puede obtener un token de ID para autenticarse en el proxy desde la API de Service Account Credentials.

En el siguiente diagrama, se muestra la arquitectura que se describe en el texto anterior:

Toda la comunicación en esta solución se realiza a través del espacio de direcciones IP internas. Los trabajadores del grupo privado no necesitan conectividad a Internet pública.

Los permisos de administración de identidades y accesos (IAM) que se otorgan a las cuentas de usuario y a las cuentas de servicio de Google no se aplican cuando se autentican con el servicio de identidad para GKE. En su lugar, debes usar el control de acceso basado en roles (RBAC) de Kubernetes para administrar los permisos del clúster en estas cuentas.

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. Install the Google Cloud CLI.

3. To initialize the gcloud CLI, run the following command:

   gcloud init

4. Create or select a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   • Create a Google Cloud project:

     gcloud projects create PROJECT_ID

     Replace PROJECT_ID with a name for the Google Cloud project you are creating.

   • Select the Google Cloud project that you created:

     gcloud config set project PROJECT_ID

     Replace PROJECT_ID with your Google Cloud project name.

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

6. Enable the Cloud Build, GKE, Identity-Aware Proxy (IAP), and Service Networking APIs APIs:

   gcloud services enable cloudbuild.googleapis.com container.googleapis.com iap.googleapis.com servicenetworking.googleapis.com

7. Install the Google Cloud CLI.

8. To initialize the gcloud CLI, run the following command:

   gcloud init

9. Create or select a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   • Create a Google Cloud project:

     gcloud projects create PROJECT_ID

     Replace PROJECT_ID with a name for the Google Cloud project you are creating.

   • Select the Google Cloud project that you created:

     gcloud config set project PROJECT_ID

     Replace PROJECT_ID with your Google Cloud project name.

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

11. Enable the Cloud Build, GKE, Identity-Aware Proxy (IAP), and Service Networking APIs APIs:

    gcloud services enable cloudbuild.googleapis.com container.googleapis.com iap.googleapis.com servicenetworking.googleapis.com

Crea un clúster de GKE privado

1. En Cloud Shell, crea un clúster de GKE que no tenga acceso de clientes al extremo público del plano de control y que tenga instalado Identity Service para GKE:

   gcloud container clusters create CLUSTER  \
     --enable-identity-service \
     --enable-ip-alias \
     --enable-master-authorized-networks \
     --enable-private-endpoint \
     --enable-private-nodes \
     --master-ipv4-cidr CONTROL_PANE_CIDR \
     --network NETWORK\
     --release-channel regular \
     --scopes cloud-platform \
     --subnetwork SUBNET \
     --tags NODE_TAGS \
     --workload-pool PROJECT_ID.svc.id.goog \
     --zone ZONE
   

   Reemplaza lo siguiente:

   • CLUSTER: el nombre del clúster En este instructivo, usa private-cluster
   • CONTROL_PANE_CIDR: El rango de direcciones IP del plano de control. Debe tener un prefijo /28. Para este instructivo, puedes usar 172.16.0.32/28.
   • NETWORK: Es la red de VPC a la que se conecta el plano de control. En este instructivo, usa default
   • SUBNET: Es la subred a la que se conecta el plano de control del clúster de GKE. La subred debe pertenecer a la red de VPC que especifica NETWORK. En este instructivo, usa default.
   • NODE_TAGS: Es una lista de etiquetas de red separadas por comas para aplicar a los nodos. En este instructivo, usa private-cluster-node.
   • PROJECT_ID: Es el ID de tu proyecto de Google Cloud.
   • ZONE: Es la zona del clúster de GKE. En este instructivo, usa us-central1-f.

   Ten en cuenta lo siguiente sobre el comando:

   • La marca --enable-identity-service habilita Identity Service para GKE en el clúster. En tu propio entorno, puedes habilitar Identity Service para GKE en un clúster existente.

   • La marca --enable-private-endpoint configura el plano de control para que solo se pueda acceder a él con direcciones IP internas.

   • La marca --enable-private-nodes configura los nodos del clúster para que solo tengan direcciones IP internas.

   • Las marcas --enable-master-authorized-networks y --enable-private-nodes permiten el acceso al servidor de la API solo desde las redes privadas que especifica la marca --network.

   • La marca opcional --workload-pool habilita la Federación de identidades para cargas de trabajo para GKE. No es necesario para este instructivo.

2. Agrega una regla de firewall que permita que el clúster de GKE control para conectarse al webhook de validación de admisión para los recursos de ClientConfig:

   gcloud compute firewall-rules create allow-control-plane-clientconfig-webhook \
     --allow tcp:15000 \
     --network NETWORK\
     --source-ranges CONTROL_PANE_CIDR\
     --target-tags NODE_TAGS
   

   ClientConfig es un tipo de recurso personalizado (CRD) de Kubernetes que Identity Service para GKE usa para configurar interactuar con proveedores de identidad.

Registra Identity Service para GKE como una aplicación cliente de OAuth 2.0

En esta sección, registrarás el servicio de identidad para GKE como una aplicación cliente con el sistema de autenticación OAuth 2.0 de Google.

1. Abre la página Credenciales en la consola de Google Cloud.

   Abre la página Credenciales.

2. Haz clic en Crear credenciales.

3. Selecciona ID de cliente de OAuth.

   Si aún no se configuró la pantalla de consentimiento para el proyecto de Google Cloud, haz clic en Configurar pantalla de consentimiento. Sigue la documentación sobre cómo configurar la pantalla de consentimiento. En este instructivo, establece los siguientes valores:

   • Tipo de usuario puede ser Interno o Externo. Para este instructivo, puedes seleccionar Interno.
   • Los valores de Nombre de la app, Correo electrónico de asistencia al usuario y Información de contacto del desarrollador son obligatorios y pueden tener cualquier valor.
   • No necesitas agregar permisos para este instructivo.

   Cuando termines de configurar la pantalla de consentimiento, haz clic en Volver al panel y, luego, vuelve a comenzar desde el paso 1 del procedimiento actual.

4. En la lista Tipo de aplicación, selecciona Aplicación web.

5. En el campo Nombre, ingresa un nombre para el ID de cliente. En este instructivo, usa Identity Service for GKE.

6. Haz clic en Crear.

   Aparecerá un cuadro de diálogo. Copia el valor de Tu ID de cliente. lo necesitarás más adelante en esta procedimiento.

7. Haz clic en Aceptar para cerrar el cuadro de diálogo.

8. En Cloud Shell, crea un directorio debajo de tu directorio principal llamado cloud-build-private-pools-gke-tutorial y, luego, ve a ese directorio:

   mkdir -p ~/cloud-build-private-pools-gke-tutorial cd ~/cloud-build-private-pools-gke-tutorial

9. En el directorio nuevo, crea un archivo YAML llamado client-config-patch.yaml que tenga los valores que necesitarás más adelante para aplicar parches al servicio de identidad para el recurso ClientConfig de GKE:

   cat << EOF > client-config-patch.yaml
   spec:
     authentication:
     - name: google-oidc
       oidc:
         clientID: CLIENT_ID
         cloudConsoleRedirectURI: https://console.cloud.google.com/kubernetes/oidc
         extraParams: prompt=consent,access_type=offline
         issuerURI: https://accounts.google.com
         kubectlRedirectURI: http://localhost:10000/callback
         scopes: email
         userClaim: email
         userPrefix: '-'
   EOF
   

   Reemplaza CLIENT_ID por el ID de cliente de OAuth del paso anterior.

   Ten en cuenta lo siguiente sobre el parche:

   • Los tokens de ID que emite el sistema de autenticación de OAuth 2.0 de Google contienen un identificador numérico único en la subreclamación (sujeto). El uso de este identificador opaco en las vinculaciones de roles dificulta la identificación del tema de una vinculación de rol. Por lo tanto, este parche configura Identity Service para que GKE use la reclamación de correo electrónico de los tokens de ID para identificar a los usuarios en lugar de usar la reclamación secundaria predeterminada.

   • El alcance de correo electrónico se agrega para que los tokens de ID emitidos incluyan la reclamación de correo electrónico.

   • Los campos cloudConsoleRedirectURI, extraParams, kubectlRedirectURI y los alcances se usan cuando los desarrolladores se autentican en el clúster con Identity Service para GKE. No se usan cuando las cuentas de servicio de Google se autentican en el clúster. El campo kubectlRedirectURI es obligatorio.

   • El campo userPrefix es un prefijo para los usuarios que se autentican con el proveedor de identidad configurado. El valor '-' significa que no hay prefijo.

   • El campo spec.authentication es un array. Puedes usar varios proveedores de identidad de OpenID Connect con Identity Service para GKE. Por ejemplo, puedes usar Google como proveedor de identidad para autenticar las cuentas de servicio de Google y un proveedor de identidad diferente para autenticar a los desarrolladores.

   Para obtener más información sobre los campos de esta configuración, consulta Usa proveedores de identidad externos para autenticarte en GKE.

Crea una cuenta de servicio de Google para configurar Identity Service para GKE

1. En Cloud Shell, crea una cuenta de servicio de Google:

   gcloud iam service-accounts create ISG_GSA \
     --display-name "Configure Identity Service for GKE"
   

   Reemplaza ISG_GSA por el nombre que deseas usar para la cuenta de servicio de Google. En este instructivo, usa identity-service-for-gke

   Debes asignar esta cuenta de servicio de Google a una instancia de VM de Compute Engine para configurar el servicio de identidad para GKE y el control de acceso basado en roles de Kubernetes en el clúster.

2. Otorga el rol de Administrador de Kubernetes Engine en el proyecto a la cuenta de servicio de Google:

   gcloud projects add-iam-policy-binding PROJECT_ID \
     --member serviceAccount:ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
     --role roles/container.admin
   

   Este rol proporciona los permisos necesarios para realizar las siguientes tareas en este instructivo:

   • Configura la configuración de Identity Service para GKE en los clústeres del proyecto.
   • Crea vinculaciones de roles y vinculaciones de roles de clúster en el clúster.

Configura Identity Service para GKE

Para configurar Identity Service para GKE, debes tener acceso al plano de control del clúster. En este instructivo, crearás una instancia de VM de Compute Engine para acceder al plano de control.

Necesitas acceso SSH a la instancia de VM. Para habilitar el acceso SSH autenticado y autorizado desde fuera de la red de VPC a la instancia de VM, usa el reenvío de TCP con Identity-Aware Proxy (IAP). Esta función habilita el acceso SSH sin que la instancia de VM tenga una dirección IP pública.

1. En Cloud Shell, crea una regla de firewall que permita el acceso SSH mediante el redireccionamiento de TCP de IAP a cualquier instancia de VM que tenga la etiqueta de red ssh-iap:

   gcloud compute firewall-rules create allow-ssh-ingress-from-iap \
     --allow tcp:22 \
     --description "Allow SSH tunneling using Identity-Aware Proxy" \
     --network NETWORK \
     --source-ranges 35.235.240.0/20 \
     --target-tags ssh-iap
   

   El rango de origen contiene las direcciones IP que IAP usa para el reenvío de TCP.

2. Crea una instancia de VM de Compute Engine en la misma red de VPC que el clúster de GKE:

   gcloud compute instances create VM \
     --metadata enable-oslogin=TRUE \
     --network NETWORK \
     --no-address \
     --scopes cloud-platform,userinfo-email \
     --service-account ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
     --subnet SUBNET  \
     --tags ssh-iap \
     --zone ZONE
   

   Reemplaza VM por el nombre que deseas usar para la instancia de VM. En este instructivo, usa identity-service-for-gke-configuration

   Ten en cuenta lo siguiente sobre el comando anterior:

   • La marca --service-account conecta la cuenta de servicio de Google a la instancia de VM.

   • El permiso cloud-platform es obligatorio para acceder a la cuenta de servicio API de Credentials.

   • El permiso userinfo-email es útil cuando se crea una instancia de VM para administrar el control de acceso basado en roles de Kubernetes. Es opcional para este instructivo.

   • La marca --no-address indica que la instancia de VM se creó sin una dirección IP externa.

   • El valor opcional de metadatos de la instancia enable-oslogin habilita el Acceso al SO en la instancia de la VM. El Acceso al SO permite administrar el acceso SSH a instancias de VM con IAM.

3. Copia el archivo de parche ClientConfig a la instancia de VM:

   gcloud compute scp client-config-patch.yaml VM:~ --tunnel-through-iap --zone ZONE
   

   La marca --tunnel-through-iap le indica a gcloud que haga un túnel para la conexión a través de IAP.

4. Conéctate a la instancia de VM mediante SSH:

   gcloud compute ssh VM --tunnel-through-iap --zone ZONE
   

   Ejecuta el resto de los comandos en esta sección desde la sesión de SSH.

5. Instala la herramienta de línea de comandos kubectl y el objeto binario gke-gcloud-auth-plugin en la instancia de la VM:

   sudo apt-get install -y kubectl google-cloud-sdk-gke-gcloud-auth-plugin
   

6. Recupera las credenciales del clúster de GKE:

   export USE_GKE_GCLOUD_AUTH_PLUGIN=True
   gcloud container clusters get-credentials CLUSTER --zone ZONE
   

7. Aplica un parche al recurso ClientConfig predeterminado:

   kubectl patch clientconfig default \
       --namespace kube-public \
       --patch-file client-config-patch.yaml \
       --type merge
   

8. Extrae el campo certificateAuthorityData del recurso ClientConfig predeterminado con parche y almacénalo en un archivo llamado certificateAuthorityData.pem:

   kubectl get clientconfig default \
        --namespace kube-public \
        --output jsonpath='{.spec.certificateAuthorityData}' \
        | base64 --decode > certificateAuthorityData.pem
   

9. Extrae el campo de servidor del recurso ClientConfig predeterminado parcheado y almacénalo en un archivo llamado server.txt:

   kubectl get clientconfig default \
        --namespace kube-public \
        --output jsonpath='{.spec.server}' > server.txt
   

10. Sal de la sesión de SSH:

    exit
    

Verifica la configuración del clúster (opcional)

Antes de continuar, puedes verificar que Identity Service para GKE se configuró de forma correcta en el clúster. Verificas la configuración con la cuenta de servicio de Google conectada a la instancia de VM para autenticarse en el clúster con Identity Service para GKE.

1. En Cloud Shell, otórgale a la cuenta de servicio Creador de tokens de identidad de OpenID Connect para la cuenta de servicio en la cuenta de servicio de Google:

   gcloud iam service-accounts add-iam-policy-binding \
     ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
     --member serviceAccount:ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
     --role roles/iam.serviceAccountOpenIdTokenCreator
   

   Este rol proporciona el permiso iam.serviceAccounts.getOpenIdToken que se requiere para solicitar tokens de ID para la cuenta de servicio desde la API de Service Account Credentials.

2. Conéctate a la instancia de VM mediante SSH:

   gcloud compute ssh VM --tunnel-through-iap --zone ZONE
   

   Ejecuta el resto de los comandos en esta sección desde la sesión de SSH.

3. Solicita un token de acceso de OAuth 2.0 al servidor de metadatos para la cuenta de servicio de Google que está conectada a la instancia de VM. Para ello, usa el ID de cliente de OAuth como el reclamo aud (público) solicitado:

   ACCESS_TOKEN=$(curl --silent --header "Metadata-Flavor: Google" \
   http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token \
          | python3 -c 'import json, sys; print(json.load(sys.stdin).get("access_token"))')
   

   El cuerpo de la respuesta del servidor de metadatos es un documento JSON. El comando usa una secuencia de comandos de Python intercalada para extraer el campo access_token del cuerpo de la respuesta.

4. Solicita un token de ID de la API de Service Account Credentials para la cuenta de servicio de Google que está conectada a la instancia de VM:

   ID_TOKEN=$(curl --silent --request POST \
       --data '{"audience": "CLIENT_ID", "includeEmail": true}' \
       --header "Authorization: Bearer $ACCESS_TOKEN" \
       --header "Content-Type: application/json; charset=utf-8" \
   "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/ISG_GSA@PROJECT_ID.iam.gserviceaccount.com:generateIdToken" \
          | python3 -c 'import json, sys; print(json.load(sys.stdin).get("token"))')
   

   Ten en cuenta lo siguiente sobre el comando anterior:

   • El campo audience en el JSON del cuerpo de la solicitud especifica el reclamo aud (público) solicitado del token de ID.
   • El token de acceso del paso anterior se usa para autenticarse en la API.

5. Consulta los reclamos en el token de ID:

   echo $ID_TOKEN \
       | cut -d. -f2 \
       | base64 --decode --ignore-garbage 2> /dev/null \
       | python3 -m json.tool
   

   Verifica que el reclamo email contenga la dirección de correo electrónico de la cuenta de servicio de Google.

6. Usa el token de ID para autenticarte en el plano de control con Identity Service para GKE:

   kubectl get namespaces \
       --certificate-authority certificateAuthorityData.pem \
       --server $(cat server.txt) \
       --token $ID_TOKEN
   

   El resultado se ve de la manera siguiente:

     Error from server (Forbidden): namespaces is forbidden: User "ISG_GSA@PROJECT_ID.iam.gserviceaccount.com" cannot list resource "namespaces" in API group "" at the cluster scope
   

   Se espera que surja este error. Aunque se otorgaron permisos de IAM a la cuenta de servicio de Google en los clústeres de GKE del proyecto, estos no se aplican cuando te autenticas con el servicio de identidad para GKE. En su lugar, configuras el acceso con el control de acceso basado en roles (RBAC) de Kubernetes.

7. Crea una vinculación de función de clúster que otorgue el rol de clúster view a la cuenta de servicio de Google cuando esta se autentique en el clúster con el proveedor de OpenID Connect de Google:

   kubectl create clusterrolebinding ISG_GSA-cluster-view \
       --clusterrole view \
       --user ISG_GSA@PROJECT_ID.iam.gserviceaccount.com
   

   Si estableces un valor userPrefix distinto de - en ClientConfig en tu propio entorno, agrega el prefijo al valor de la marca --user en este comando.

8. Accede al clúster de GKE con Identity Service para GKE:

   kubectl get namespaces \
       --certificate-authority certificateAuthorityData.pem \
       --server $(cat server.txt) \
       --token $ID_TOKEN
   

   El resultado se ve de la manera siguiente:

   NAME                      STATUS   AGE
   anthos-identity-service   Active   1h
   default                   Active   1h
   kube-node-lease           Active   1h
   kube-public               Active   1h
   kube-system               Active   1h
   

9. Sal de la sesión de SSH:

   exit
   

Crea un contexto para la herramienta de kubectl

El comando kubectl puede usar un archivo kubeconfig para configurar el acceso a los clústeres. Un archivo kubeconfig contiene uno o más contextos. Cada contexto tiene un nombre y, de forma opcional, incluye información de conectividad del clúster, credenciales que se usan para autenticarse en el clúster y un espacio de nombres predeterminado.

En esta sección, crearás un archivo kubeconfig que tenga un contexto. El contexto incluye los detalles de conectividad del proxy de Identity Service para GKE de tu clúster. No agregues ninguna credencial de usuario al archivo kubeconfig.

1. En Cloud Shell, copia los archivos que contienen los datos de la autoridad certificadora y la URL del servidor de la instancia de VM en el directorio actual:

   gcloud compute scp VM:~/certificateAuthorityData.pem VM:~/server.txt . \
       --tunnel-through-iap --zone ZONE
   

2. Crea un contexto y una configuración de clúster que usarás más adelante para conectarte al clúster de GKE desde Cloud Build:

   kubectl config set-context private-cluster \
       --cluster private-cluster \
       --kubeconfig kubeconfig
   

   La marca --kubeconfig crea el contexto y la configuración del clúster en un archivo nuevo llamado kubeconfig en el directorio actual.

   Este comando usa el nombre del clúster de GKE como el nombre de la configuración del clúster para el contexto. En tu propio entorno, puedes usar un nombre de configuración de clúster diferente en el contexto.

3. Establece el campo certificateAuthorityData en la configuración del clúster:

   kubectl config set-cluster private-cluster \
       --certificate-authority certificateAuthorityData.pem \
       --embed-certs \
       --kubeconfig kubeconfig
   

4. Establece el campo server en la configuración del clúster:

   kubectl config set-cluster private-cluster \
       --kubeconfig kubeconfig \
       --server $(cat server.txt)
   

Crea una cuenta de servicio de Google para Cloud Build

1. En Cloud Shell, crea una cuenta de servicio de Google para ejecutar compilaciones en la Grupo privado de Cloud Build:

   gcloud iam service-accounts create CB_GSA \
     --description "Runs builds on Cloud Build private pools" \
     --display-name "Cloud Build private pool"
   

   Reemplaza CB_GSA por el nombre que deseas usar para la cuenta de servicio de Google. En este instructivo, usa cloud-build-private-pool

2. Otorga el rol de cuenta de servicio de Cloud Build en el proyecto a la cuenta de servicio de Google:

   gcloud projects add-iam-policy-binding PROJECT_ID \
       --member serviceAccount:CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/cloudbuild.builds.builder
   

   Este rol proporciona los permisos predeterminados de la cuenta de servicio de Cloud Build administrada por Google.

3. Otorga el rol de creador de tokens de identidad de OpenID Connect para cuentas de servicio en la cuenta de servicio de Google a la cuenta de servicio en sí:

   gcloud iam service-accounts add-iam-policy-binding \
       CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --member serviceAccount:CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/iam.serviceAccountOpenIdTokenCreator
   

   Este rol proporciona el permiso iam.serviceAccounts.getOpenIdToken, necesario para solicitar tokens de ID para la cuenta de servicio desde la API de Service Account Credentials.

4. Conéctate a la instancia de VM mediante SSH:

   gcloud compute ssh VM --tunnel-through-iap --zone ZONE
   

   Ejecuta el resto de los comandos en esta sección desde la sesión de SSH.

5. En la sesión de SSH, crea una vinculación de rol de clúster de Kubernetes que otorgue el rol de clúster cluster-admin a la cuenta de servicio de Google cuando la cuenta de servicio se autentique en el clúster con el proveedor de OpenID Connect de Google:

   kubectl create clusterrolebinding CB_GSA-cluster-admin \
       --clusterrole cluster-admin \
       --user CB_GSA@PROJECT_ID.iam.gserviceaccount.com
   

   El rol de clúster cluster-admin otorga permisos amplios en todo el clúster. En tu propio entorno, puedes usar un rol de clúster que proporcione solo los permisos necesarios para las tareas que realiza Cloud Build. También puedes usar vinculaciones de roles para otorgar permisos solo a espacios de nombres específicos.

   Si configuras un userPrefix en ClientConfig en tu propio entorno, debes agregar ese prefijo al valor de la marca --user en este comando.

6. Sal de la sesión de SSH:

   exit
   

Crea un grupo privado de Cloud Build

1. En Cloud Shell, asigna un rango de direcciones IP en tu red de VPC para la conexión con el grupo privado:

   gcloud compute addresses create RESERVED_RANGE_NAME \
   --addresses RESERVED_RANGE_START_IP\
       --description "Cloud Build private pool reserved range" \
       --global \
       --network NETWORK \
       --prefix-length RESERVED_RANGE_PREFIX_LENGTH \
       --purpose VPC_PEERING
   

   Reemplaza lo siguiente:

   • RESERVED_RANGE_NAME: Es el nombre del rango de direcciones IP asignadas que aloja el grupo privado de Cloud Build. En este instructivo, usa cloud-build-private-pool
   • RESERVED_RANGE_START_IP: Es la primera dirección IP del rango de direcciones IP asignado. En este instructivo, usa 192.168.12.0
   • RESERVED_RANGE_PREFIX_LENGTH: La longitud del prefijo (máscara de subred) del rango de direcciones IP asignado. La longitud del prefijo debe ser /23 o un número menor, por ejemplo, /22 o /21. Cuanto más bajo sea el número, mayor será el rango de direcciones. Para este instructivo, usa 23 y no ingreses la / inicial (barra).

2. Crea una regla de firewall para permitir el tráfico entrante desde el rango de direcciones IP reservado a otros recursos en tu red de VPC:

   gcloud compute firewall-rules create allow-private-pools-ingress \
       --allow all \
       --network NETWORK \
       --source-ranges RESERVED_RANGE_START_IP/RESERVED_RANGE_PREFIX_LENGTH
   

3. Crea una conexión privada a servicios para conectar tu red de VPC al servicio de Service Networking:

   gcloud services vpc-peerings connect \
       --network NETWORK \
       --ranges RESERVED_RANGE_NAME \
       --service servicenetworking.googleapis.com
   

   Los grupos privados de Cloud Build ejecutan trabajadores con Service Networking. La conexión privada a servicios permite que tu red de VPC se comunique con el grupo privado en el rango asignado de direcciones IP internas a través de una conexión de intercambio de tráfico entre redes de VPC.

   Crear la conexión privada al servicio puede tardar unos minutos.

   Si usas una VPC compartida en tu propio entorno, consulta Configura tu entorno para obtener información sobre los pasos adicionales para crear la conexión de servicio privada.

4. Crea un grupo privado de Cloud Build en una red de VPC de Google que intercambia el tráfico con tu red de VPC:

   gcloud builds worker-pools create PRIVATE_POOL_NAME \
      --no-public-egress \
      --peered-network projects/PROJECT_ID/global/networks/NETWORK \
      --region REGION
   

   Reemplaza lo siguiente:

   • PRIVATE_POOL_NAME: Es el nombre del grupo privado. En este instructivo, usa private-pool
   • REGION: Es la región que se usará para el grupo privado. En este instructivo, usa us-central1.

   La marca --no-public-egress significa que los trabajadores del grupo privado no tienen direcciones IP públicas. En tu propio entorno, puedes quitar esta marca si quieres que los trabajadores del grupo privado tengan conectividad a Internet mediante direcciones IP públicas.

   Para obtener información sobre opciones de configuración adicionales, como el tipo de máquina y el tamaño del disco para los trabajadores del grupo privado, consulta Cómo crear y administrar grupos privados.

Verifica la solución

En esta sección, verificarás la solución ejecutando una compilación en el grupo privado de Cloud Build. La compilación accede al clúster privado de GKE.

1. En Cloud Shell, crea un bucket de Cloud Storage para almacenar registros de compilación desde Cloud Build:

   gcloud storage buckets create gs://PROJECT_ID-build-logs --location=REGION
   

2. Crea un archivo de configuración de compilación para Cloud Build:

   cat << "EOF" > cloudbuild.yaml
   steps:
   - id: list-services
     name: gcr.io/google.com/cloudsdktool/google-cloud-cli
     entrypoint: bash
     args:
     - -eEuo
     - pipefail
     - -c
     - |-
       kubectl config use-context $_KUBECTL_CONTEXT
   
       ACCESS_TOKEN=$$(curl --silent \
           --header "Metadata-Flavor: Google" \
           http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token \
           | python3 -c 'import json, sys; print(json.load(sys.stdin).get("access_token"))')
   
       ID_TOKEN=$$(curl --silent --request POST \
           --data '{"audience": "CLIENT_ID", "includeEmail": true}' \
           --header "Authorization: Bearer $$ACCESS_TOKEN" \
           --header "Content-Type: application/json; charset=utf-8" \
           "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/$_SERVICE_ACCOUNT:generateIdToken" \
           | python3 -c 'import json, sys; print(json.load(sys.stdin).get("token"))')
   
       kubectl get services --namespace $_NAMESPACE --token $$ID_TOKEN
   
   logsBucket: gs://PROJECT_ID-build-logs
   
   options:
     env:
     - KUBECONFIG=/workspace/$_KUBECONFIG
   
   substitutions:
     _KUBECONFIG: kubeconfig
     _KUBECTL_CONTEXT: private-cluster
     _NAMESPACE: default
   
   serviceAccount: projects/$PROJECT_ID/serviceAccounts/$_SERVICE_ACCOUNT
   EOF
   

   El paso del archivo de configuración de compilación hace lo siguiente:

   1. Cambia al contexto kubectl que especifica la sustitución _KUBECTL_CONTEXT. El valor de sustitución predeterminado es private-cluster.

   2. Recupera un token de acceso del servidor de metadatos. El token de acceso se emite a la cuenta de servicio de Google que ejecuta la compilación.

   3. Genera un token de ID mediante la API de Service Account Credentials. La solicitud para generar el token de ID se autentica con el token de acceso. La reclamación aud (público) solicitada del token de ID es el ID de cliente de OAuth 2.0 que especifica la sustitución _CLIENT_ID.

   4. Enumera los servicios de Kubernetes en el espacio de nombres que especifica la sustitución _NAMESPACE. El valor de sustitución predeterminado es default. La solicitud se autentica con el token de ID que se generó en el comando anterior.

   Ten en cuenta lo siguiente sobre el archivo de configuración de compilación:

   • El carácter $ es el prefijo de las sustituciones. $$ se usa para la expansión de parámetros de Bash y la sustitución de comandos.

   • Las sustituciones _KUBECONFIG y _KUBECTL_CONTEXT permiten que se especifiquen diferentes archivos kubeconfig y contextos cuando ejecutas una compilación. Estas sustituciones te permiten administrar varias configuraciones de clústeres con un solo archivo kubeconfig con varios contextos o con varios archivos kubeconfig.

   • La sustitución _SERVICE_ACCOUNT no tiene un valor predeterminado. Debes proporcionar un valor para esta sustitución cuando ejecutes una compilación.

   • El bloque options establece la variable de entorno KUBECONFIG para todos los pasos de la compilación.

   • En el paso de compilación, se usa la imagen del compilador de gcr.io/google.com/cloudsdktool/google-cloud-cli. Esta es una imagen de contenedor grande y tarda un poco en extraerse del registro al trabajador del grupo privado. Para reducir el tiempo que se tarda en extraer la imagen del compilador, puedes crear una imagen de compilador personalizada que contenga solo las herramientas necesarias para el paso de compilación, como curl, kubectl y Python.

   Para obtener más información sobre las secuencias de comandos de shell intercaladas en los archivos de configuración de compilación, consulta Cómo ejecutar secuencias de comandos de Bash.

3. Ejecuta una compilación con el archivo de configuración de compilación y los archivos en el directorio actual:

   gcloud builds submit \
       --config cloudbuild.yaml \
       --region REGION \
       --substitutions _SERVICE_ACCOUNT=CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --worker-pool projects/PROJECT_ID/locations/REGION/workerPools/PRIVATE_POOL_NAME
   

   El comando sube todos los archivos que se encuentran en el directorio actual a Cloud Storage para que los use Cloud Build. El paso de compilación usa el archivo kubeconfig para conectarse al clúster de GKE.

   Cerca del final del resultado, verás líneas similares a las siguientes:

   NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
   kubernetes   ClusterIP   10.0.0.1     <none>        443/TCP   2h
   

   Este resultado muestra que el trabajador del grupo privado se conectó al plano de control del clúster con el proxy de autenticación de Identity Service para GKE.

Soluciona problemas

Si no puedes conectarte a la instancia de VM mediante SSH, agrega la marca --troubleshoot para descubrir la causa de los problemas de conectividad:

gcloud compute ssh VM --tunnel-through-iap --zone ZONE --troubleshoot

Si recibes el mensaje Error from server (NotFound): clientconfigs.authentication.gke.io "default" not found cuando aplicas el parche a la ClientConfig predeterminada en el clúster de GKE, asegúrate de haber creado la regla de firewall como se describe en la sección Crea un clúster de GKE privado. Verifica que exista la regla de firewall:

gcloud compute firewall-rules describe allow-control-plane-clientconfig-webhook

Si no puedes autenticarte en el proxy de Identity Service para GKE, busca errores en los registros de los pods de la implementación de gke-oidc-service:

gcloud compute ssh VM --tunnel-through-iap --zone ZONE --command \
    'kubectl logs deployment/gke-oidc-service \
         --namespace anthos-identity-service --all-containers'

Si tienes otros problemas con este instructivo, te recomendamos que revises estos documentos:

• Solución de problemas de GKE
• Solución de problemas de los clústeres de Kubernetes

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.

Borra el proyecto

Precaución: Borrar un proyecto tiene estas consecuencias:

• Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
• Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

Borra un proyecto de Google Cloud:

gcloud projects delete PROJECT_ID

Borra los recursos

Si deseas conservar el proyecto que usaste en este instructivo, borra los recursos individuales:

1. En Cloud Shell, borra el grupo privado de Cloud Build:

   gcloud builds worker-pools delete PRIVATE_POOL_NAME --region REGION --quiet
   

2. Borra la conexión de servicio privada a Service Networking:

   gcloud services vpc-peerings delete --network NETWORK \
     --service servicenetworking.googleapis.com --quiet --async
   

3. Borra el rango de direcciones IP asignado a los grupos privados de Cloud Build:

   gcloud compute addresses delete RESERVED_RANGE_NAME --global --quiet
   

4. Borra el bucket de Cloud Storage y todo su contenido:

   gcloud storage rm gs://PROJECT_ID-build-logs --recursive
   

5. Borra el clúster de GKE:

   gcloud container clusters delete CLUSTER --zone ZONE --quiet --async
   

6. Borra la instancia de VM de Compute Engine:

   gcloud compute instances delete VM --zone ZONE --quiet
   

7. Borra las reglas de firewall:

   gcloud compute firewall-rules delete allow-private-pools-ingress --quiet
   
   gcloud compute firewall-rules delete allow-ssh-ingress-from-iap --quiet
   
   gcloud compute firewall-rules delete allow-control-plane-clientconfig-webhook --quiet
   

8. Quita las vinculaciones de roles de IAM:

   gcloud projects remove-iam-policy-binding PROJECT_ID \
       --member serviceAccount:CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/cloudbuild.builds.builder
   
   gcloud projects remove-iam-policy-binding PROJECT_ID \
       --member serviceAccount:ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/container.admin
   
   gcloud iam service-accounts remove-iam-policy-binding \
       CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --member serviceAccount:CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/iam.serviceAccountOpenIdTokenCreator
   
   gcloud iam service-accounts remove-iam-policy-binding \
       ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --member serviceAccount:ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/iam.serviceAccountOpenIdTokenCreator
   

9. Borra las cuentas de servicio de Google:

   gcloud iam service-accounts delete CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
      --quiet
   
   gcloud iam service-accounts delete ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
      --quiet
   

Borra el ID de cliente de OAuth 2.0

1. Ve a la página Credenciales en la consola de Google Cloud:

   Abre la página Credenciales.

2. Selecciona tu proyecto en la lista del selector de proyectos.

3. En la tabla de IDs de cliente de OAuth 2.0, busca la fila de Identity Service for GKE y, luego, haz clic en el ícono Delete OAuth client.

4. En el cuadro de diálogo, haz clic en Borrar.

¿Qué sigue?

• Obtén más información para acceder a los clústeres de Anthos desde Cloud Build con la puerta de enlace de conexión.
• Obtén más información sobre cómo acceder a clústeres de GKE privados con grupos privados de Cloud Build mediante Cloud VPN.
• Obtén información para crear clústeres privados de GKE con proxies de red para acceder al plano de control.
• Obtén información sobre cómo acceder a recursos externos en una red privada mediante una IP externa estática.
• Descubre GKE Identity Service. GKE Identity Service te permite administrar la autenticación de proveedores de identidad externos en una flota de clústeres de Anthos.