Crea recursos de Google Cloud que cumplan con las políticas

En este instructivo, se muestra cómo los administradores de la plataforma pueden usar las políticas de Policy Controller para regular cómo crear Google Cloud recursos conConfig Connector.

Esta página está destinada a los administradores de TI y operadores que desean asegurarse de que todos los recursos que se ejecutan dentro de la plataforma en la nube cumplan con los requisitos de cumplimiento de la organización. Para ello, deben proporcionar y mantener la automatización para auditar o aplicar el cumplimiento, y administran el ciclo de vida de la infraestructura tecnológica subyacente. Para obtener más información sobre los roles comunes y las tareas de ejemplo a las que hacemos referencia en el contenido deGoogle Cloud , consulta Tareas y roles comunes de los usuarios de GKE Enterprise.

En las instrucciones de este instructivo, se supone que tienes conocimientos básicos de Kubernetes o Google Kubernetes Engine (GKE). En el instructivo, defines una política que restringe las ubicaciones permitidas para los buckets de Cloud Storage.

Realiza verificaciones del controlador de políticas, auditorías, y aplica el cumplimiento de tus recursos de clúster de Kubernetes con políticas relacionadas con las reglas empresariales, de seguridad o la normativa. El controlador de políticas se compila a partir del proyecto de código abierto Gatekeeper.

Config Connector crea y administra el ciclo de vida de los recursos deGoogle Cloud describiéndolos como recursos personalizados de Kubernetes. Para crear un recurso Google Cloud , debes crear un recurso de Kubernetes en un espacio de nombres que administra Config Connector. En el siguiente ejemplo, se muestra cómo describir un depósito de Cloud Storage con Config Connector:

apiVersion: storage.cnrm.cloud.google.com/v1beta1
kind: StorageBucket
metadata:
  name: my-bucket
spec:
  location: us-east1

Cuando administras tus recursos de Google Cloud con Config Connector, puedes aplicar las políticas de Policy Controller a esos recursos a medida que los creas en tu clúster de Google Kubernetes Engine (GKE) de edición empresarial. Estas políticas te permiten evitar o informar acciones que creen o modifiquen recursos de formas que infrinjan tus políticas. Por ejemplo, puedes aplicar una política que restrinja las ubicaciones de los depósitos de Cloud Storage.

Este enfoque, basado en el modelo de recursos de Kubernetes (KRM), te permite usar un conjunto coherente de herramientas y flujos de trabajo para administrar tanto recursos de Kubernetes como de Google Cloud . En este instructivo, se muestra cómo completar las siguientes tareas:

  • Define políticas que rijan tus Google Cloud recursos.
  • Implementar controles que impidan que los desarrolladores y administradores creen recursos de Google Cloud que infrinjan tus políticas
  • Implementa controles que auditen tus recursos Google Cloud existentes en relación con tus políticas, incluso si creaste esos recursos fuera de Config Connector.
  • Proporciona comentarios rápidos a los desarrolladores y administradores a medida que crean y actualizan las definiciones de recursos.
  • Validar las Google Cloud definiciones de recursos según tus políticas antes de intentar aplicar las definiciones a un clúster de Kubernetes.

Objetivos

  • Crear un clúster de Google Kubernetes Engine (GKE) de edición empresarial que incluya el complemento de Config Connector
  • Instala Policy Controller.
  • Crear una política de Gatekeeper para restringir las ubicaciones permitidas para depósitos de Cloud Storage
  • Verificar que la política de Gatekeeper impida la creación de depósitos de Cloud Storage en ubicaciones no permitidas
  • Evaluar el cumplimiento de políticas de la definición de depósito de Cloud Storage durante el desarrollo
  • Auditar los depósitos de Cloud Storage existentes para cumplir con las políticas

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.

Antes de comenzar

  1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  2. Make sure that billing is enabled for your Google Cloud project.

  3. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

  4. En Cloud Shell, configura el proyecto de Google Cloud que deseas usar para este instructivo:

    gcloud config set project PROJECT_ID

    Reemplaza PROJECT_ID por el ID de tu proyecto de Google Cloud. Cuando ejecutas este comando, Cloud Shell crea una variable de entorno exportada llamada GOOGLE_CLOUD_PROJECT que contiene el ID de tu proyecto. Si no usas Cloud Shell, puedes crear la variable de entorno con este comando:

    export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value core/project)

  5. Habilita la API de GKE:

    gcloud services enable container.googleapis.com

  6. Habilita la API de Policy Controller:

    gcloud services enable anthospolicycontroller.googleapis.com

  7. Crea un directorio para almacenar los archivos creados en este instructivo:

    mkdir -p ~/cnrm-gatekeeper-tutorial

  8. Ve al directorio que creaste:

    cd ~/cnrm-gatekeeper-tutorial

Crea un clúster de GKE

  1. En Cloud Shell, crea un clúster de GKE con el complemento de Config Connector y Workload Identity Federation for GKE:

    gcloud container clusters create CLUSTER_NAME \
  --addons ConfigConnector \
  --enable-ip-alias \
  --num-nodes 4 \
  --release-channel regular \
  --scopes cloud-platform \
  --workload-pool $GOOGLE_CLOUD_PROJECT.svc.id.goog \
  --zone ZONE

    Reemplaza lo siguiente:

    • CLUSTER_NAME: El nombre del clúster que deseas usar para este proyecto, por ejemplo, cnrm-gatekeeper-tutorial.
    • ZONE: Una zona de Compute Engine cerca de tu ubicación, por ejemplo, asia-southeast1-b.

    El complemento Config Connector instala definiciones de recursos personalizados (CRD) para los recursos deGoogle Cloud en tu clúster de GKE.

  2. Opcional: Si usas un clúster privado en tu entorno, agrega una regla de firewall que permita que el plano de control del clúster de GKE se conecte al webhook de Policy Controller:

    gcloud compute firewall-rules create allow-cluster-control-plane-tcp-8443 \
  --allow tcp:8443 \
  --network default \
  --source-ranges CONTROL_PLANE_CIDR \
  --target-tags NODE_TAG

    Reemplaza lo siguiente:

    • CONTROL_PLANE_CIDR: El rango de IP para tu plano de control de clúster de GKE, por ejemplo, 172.16.0.16/28
    • NODE_TAG: La etiqueta que se aplica a todos los nodos de tu clúster de GKE.

    Esta regla de firewall opcional es obligatoria para que el webhook de Policy Controller funcione cuando tu clúster usa nodos privados.

Configura Config Connector

El Google Cloud proyecto en el que instalas Config Connector se conoce como el proyecto host. Los proyectos en los que usas Config Connector para administrar recursos se conocen como proyectos administrados. En este instructivo, usarás Config Connector para crear recursos deGoogle Cloud en el mismo proyecto que tu clúster de GKE, de modo que el proyecto host y el proyecto administrado sean el mismo proyecto.

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

    gcloud iam service-accounts create SERVICE_ACCOUNT_NAME \
  --display-name "Config Connector Gatekeeper tutorial"

    Reemplaza SERVICE_ACCOUNT_NAME por el nombre que deseas usar para esta cuenta de servicio, por ejemplo, cnrm-gatekeeper-tutorial. Config Connector usa esta cuenta de servicio de Google para crear recursos en tu proyecto administrado.

  2. Otorga el rol de administrador de almacenamiento a la cuenta de servicio de Google:

    gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
  --member "serviceAccount:SERVICE_ACCOUNT_NAME@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com" \
  --role roles/storage.admin

    En este instructivo, usarás la función Administrador de almacenamiento porque usas Config Connector para crear depósitos de Cloud Storage. En tu propio entorno, otorga los roles necesarios para administrar los Google Cloud recursos que deseas crear para Config Connector. Para obtener más información sobre las funciones predefinidas, consulta Comprende las funciones en la documentación de IAM.

  3. Crea un espacio de nombres de Kubernetes para los recursos de Config Connector que creas en este instructivo:

    kubectl create namespace NAMESPACE

    Reemplaza NAMESPACE por el espacio de nombres de Kubernetes que deseas usar en el instructivo, por ejemplo, tutorial.

  4. Anota el espacio de nombres para especificar qué proyecto de Config Connector debe usar para crear recursos de Google Cloud (el proyecto administrado):

    kubectl annotate namespace NAMESPACE \
    cnrm.cloud.google.com/project-id=$GOOGLE_CLOUD_PROJECT

  5. Crea un recurso ConfigConnectorContext que habilite Config Connector para el espacio de nombres de Kubernetes y lo asocia con la cuenta de servicio de Google que creaste:

    cat << EOF | kubectl apply -f -
apiVersion: core.cnrm.cloud.google.com/v1beta1
kind: ConfigConnectorContext
metadata:
  name: configconnectorcontext.core.cnrm.cloud.google.com
  namespace: NAMESPACE
spec:
  googleServiceAccount: SERVICE_ACCOUNT_NAME@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com
EOF

    Cuando creas el recurso ConfigConnectorContext, Config Connector crea una cuenta de servicio de Kubernetes y StatefulSet en el espacio de nombres cnrm-system para administrar los recursos de Config Connector en tu espacio de nombres.

  6. Espera el pod controlador de Config Connector para tu espacio de nombres:

    kubectl wait --namespace cnrm-system --for=condition=Ready pod \
  -l cnrm.cloud.google.com/component=cnrm-controller-manager,cnrm.cloud.google.com/scoped-namespace=NAMESPACE

    Cuando el Pod esté listo, aparecerá el símbolo del sistema de Cloud Shell. Si recibes el mensaje error: no matching resources found, espera un minuto y vuelve a intentarlo.

  7. Vincula tu cuenta de servicio de Config Connector de Kubernetes con tu cuenta de servicio de Google mediante la creación de una vinculación de política de IAM:

    gcloud iam service-accounts add-iam-policy-binding \
  SERVICE_ACCOUNT_NAME@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com \
  --member "serviceAccount:$GOOGLE_CLOUD_PROJECT.svc.id.goog[cnrm-system/cnrm-controller-manager-NAMESPACE]" \
  --role roles/iam.workloadIdentityUser

    Esta vinculación permite que la cuenta de servicio cnrm-controller-manager-NAMESPACE de Kubernetes del espacio de nombres cnrm-system actúe como la cuenta de servicio de Google que creaste.

Instalar Controlador de políticas

Instala el Policy Controller según las instrucciones de instalación.

Usa un intervalo de auditoría de 60 segundos.

Crea un recurso Google Cloud con Config Connector

  1. En Cloud Shell, crea un manifiesto de Config Connector que represente un depósito de Cloud Storage en la región us-central1:

    cat << EOF > tutorial-storagebucket-us-central1.yaml
apiVersion: storage.cnrm.cloud.google.com/v1beta1
kind: StorageBucket
metadata:
  name: tutorial-us-central1-$GOOGLE_CLOUD_PROJECT
  namespace: NAMESPACE
spec:
  location: us-central1
  uniformBucketLevelAccess: true
EOF

  2. Para crear el bucket de Cloud Storage, aplica el manifiesto:

    kubectl apply -f tutorial-storagebucket-us-central1.yaml

  3. Verifica que Config Connector haya creado el depósito de Cloud Storage:

    gcloud storage ls | grep tutorial

    El resultado es similar a este:

    gs://tutorial-us-central1-PROJECT_ID/

    Este resultado incluye PROJECT_ID, que es el ID de tu Google Cloud proyecto.

    Si no ves este resultado, espera un minuto y vuelve a realizar el paso.

Crear una política

Una política de Policy Controller consta de una plantilla de restricciones y una restricción. La plantilla de restricciones contiene la lógica de políticas. La restricción especifica dónde se aplica la política y los parámetros de entrada en la lógica de la política.

  1. En Cloud Shell, crea una plantilla de restricción que restrinja las ubicaciones de los depósitos de Cloud Storage:

    cat << EOF > tutorial-storagebucket-location-template.yaml
apiVersion: templates.gatekeeper.sh/v1beta1
kind: ConstraintTemplate
metadata:
  name: gcpstoragelocationconstraintv1
spec:
  crd:
    spec:
      names:
        kind: GCPStorageLocationConstraintV1
      validation:
        openAPIV3Schema:
          properties:
            locations:
              type: array
              items:
                type: string
            exemptions:
              type: array
              items:
                type: string
  targets:
  - target: admission.k8s.gatekeeper.sh
    rego: |
      package gcpstoragelocationconstraintv1

      allowedLocation(reviewLocation) {
          locations := input.parameters.locations
          satisfied := [ good | location = locations[_]
                                good = lower(location) == lower(reviewLocation)]
          any(satisfied)
      }

      exempt(reviewName) {
          input.parameters.exemptions[_] == reviewName
      }

      violation[{"msg": msg}] {
          bucketName := input.review.object.metadata.name
          bucketLocation := input.review.object.spec.location
          not allowedLocation(bucketLocation)
          not exempt(bucketName)
          msg := sprintf("Cloud Storage bucket <%v> uses a disallowed location <%v>, allowed locations are %v", [bucketName, bucketLocation, input.parameters.locations])
      }

      violation[{"msg": msg}] {
          not input.parameters.locations
          bucketName := input.review.object.metadata.name
          msg := sprintf("No permitted locations provided in constraint for Cloud Storage bucket <%v>", [bucketName])
      }
EOF

  2. Aplica la plantilla para crear el depósito de Cloud Storage:

    kubectl apply -f tutorial-storagebucket-location-template.yaml

  3. Crea una restricción que solo permita depósitos en las regiones de Singapur y Yakarta (asia-southeast1 y asia-southeast2). La restricción se aplica al espacio de nombres que indicaste antes. Exime al depósito de Cloud Storage predeterminado para Cloud Build.

    cat << EOF > tutorial-storagebucket-location-constraint.yaml
apiVersion: constraints.gatekeeper.sh/v1beta1
kind: GCPStorageLocationConstraintV1
metadata:
  name: singapore-and-jakarta-only
spec:
  enforcementAction: deny
  match:
    kinds:
    - apiGroups:
      - storage.cnrm.cloud.google.com
      kinds:
      - StorageBucket
    namespaces:
    - NAMESPACE
  parameters:
    locations:
    - asia-southeast1
    - asia-southeast2
    exemptions:
    - ${GOOGLE_CLOUD_PROJECT}_cloudbuild
EOF

  4. Para limitar las zonas en las que pueden existir los buckets, aplica la restricción:

    kubectl apply -f tutorial-storagebucket-location-constraint.yaml

Verifica la política

  1. Crea un manifiesto que represente un depósito de Cloud Storage en una ubicación no permitida (us-west1):

    cat << EOF > tutorial-storagebucket-us-west1.yaml
apiVersion: storage.cnrm.cloud.google.com/v1beta1
kind: StorageBucket
metadata:
  name: tutorial-us-west1-$GOOGLE_CLOUD_PROJECT
  namespace: NAMESPACE
spec:
  location: us-west1
  uniformBucketLevelAccess: true
EOF

  2. Para crear el bucket de Cloud Storage, aplica el manifiesto:

    kubectl apply -f tutorial-storagebucket-us-west1.yaml

    El resultado es similar a este:

    Error from server ([singapore-and-jakarta-only] Cloud Storage bucket
<tutorial-us-west1-PROJECT_ID> uses a disallowed location
<us-west1>, allowed locations are ["asia-southeast1",
"asia-southeast2"]): error when creating
"tutorial-storagebucket-us-west1.yaml": admission webhook
"validation.gatekeeper.sh" denied the request: [singapore-and-jakarta-only]
Cloud Storage bucket <tutorial-us-west1-PROJECT_ID> uses a
disallowed location <us-west1>, allowed locations are
["asia-southeast1", "asia-southeast2"]

  3. Opcional: Puedes ver un registro de la decisión que se rechaza en la solicitud de los Registros de auditoría de Cloud. Consulta los Registros de actividad del administrador del proyecto:

    gcloud logging read --limit=1 \
    "logName=\"projects/$GOOGLE_CLOUD_PROJECT/logs/cloudaudit.googleapis.com%2Factivity\""'
    resource.type="k8s_cluster"
    resource.labels.cluster_name="CLUSTER_NAME"
    resource.labels.location="ZONE"
    protoPayload.authenticationInfo.principalEmail!~"system:serviceaccount:cnrm-system:.*"
    protoPayload.methodName:"com.google.cloud.cnrm."
    protoPayload.status.code=7'

    El resultado es similar a este:

    insertId: 3c6940bb-de14-4d18-ac4d-9a6becc70828
labels:
  authorization.k8s.io/decision: allow
  authorization.k8s.io/reason: ''
  mutation.webhook.admission.k8s.io/round_0_index_0: '{"configuration":"mutating-webhook.cnrm.cloud.google.com","webhook":"container-annotation-handler.cnrm.cloud.google.com","mutated":true}'
  mutation.webhook.admission.k8s.io/round_0_index_1: '{"configuration":"mutating-webhook.cnrm.cloud.google.com","webhook":"management-conflict-annotation-defaulter.cnrm.cloud.google.com","mutated":true}'
logName: projects/PROJECT_ID/logs/cloudaudit.googleapis.com%2Factivity
operation:
  first: true
  id: 3c6940bb-de14-4d18-ac4d-9a6becc70828
  last: true
  producer: k8s.io
protoPayload:
  '@type': type.googleapis.com/google.cloud.audit.AuditLog
  authenticationInfo:
    principalEmail: user@example.com
  authorizationInfo:
  - permission: com.google.cloud.cnrm.storage.v1beta1.storagebuckets.create
    resource: storage.cnrm.cloud.google.com/v1beta1/namespaces/NAMESPACE/storagebuckets/tutorial-us-west1-PROJECT_ID
  methodName: com.google.cloud.cnrm.storage.v1beta1.storagebuckets.create
  requestMetadata:
    callerIp: 203.0.113.1
    callerSuppliedUserAgent: kubectl/v1.21.1 (linux/amd64) kubernetes/5e58841
  resourceName: storage.cnrm.cloud.google.com/v1beta1/namespaces/NAMESPACE/storagebuckets/tutorial-us-west1-PROJECT_ID
  serviceName: k8s.io
  status:
    code: 7
    message: Forbidden
receiveTimestamp: '2021-05-21T06:56:24.940264678Z'
resource:
  labels:
    cluster_name: CLUSTER_NAME
    location: CLUSTER_ZONE
    project_id: PROJECT_ID
  type: k8s_cluster
timestamp: '2021-05-21T06:56:09.060635Z'

    El campo methodName muestra la operación que se intentó, resourceName muestra el nombre completo del recurso de Config Connector y la sección status muestra que la solicitud no se realizó de forma correcta, con código de error 7 y mensaje Forbidden.

  4. Crea un manifiesto que represente un depósito de Cloud Storage en una ubicación permitida (asia-southeast1):

    cat << EOF > tutorial-storagebucket-asia-southeast1.yaml
apiVersion: storage.cnrm.cloud.google.com/v1beta1
kind: StorageBucket
metadata:
  name: tutorial-asia-southeast1-$GOOGLE_CLOUD_PROJECT
  namespace: NAMESPACE
spec:
  location: asia-southeast1
  uniformBucketLevelAccess: true
EOF

  5. Para crear el bucket de Cloud Storage, aplica el manifiesto:

    kubectl apply -f tutorial-storagebucket-asia-southeast1.yaml

    El resultado es similar a este:

    storagebucket.storage.cnrm.cloud.google.com/tutorial-asia-southeast1-PROJECT_ID created

    Este resultado incluye PROJECT_ID, que es el ID de tu Google Cloud proyecto.

  6. Verifica que Config Connector haya creado el depósito de Cloud Storage:

    gcloud storage ls | grep tutorial

    El resultado es similar a este:

    gs://tutorial-asia-southeast1-PROJECT_ID/
gs://tutorial-us-central1-PROJECT_ID/

    Si no ves este resultado, espera un minuto y vuelve a realizar este paso.

Auditoría de restricciones

El controlador de auditoría de Policy Controller evalúa de forma periódica los recursos según sus restricciones. El controlador detecta los incumplimientos de políticas de los recursos creados antes que la restricción y los recursos creados fuera de Config Connector.

  1. En Cloud Shell, observa los incumplimientos de todas las restricciones que usan la plantilla de restricción GCPStorageLocationConstraintV1:

    kubectl get gcpstoragelocationconstraintv1 -o json \
  | jq '.items[].status.violations'

    El resultado es similar a este:

    [
  {
    "enforcementAction": "deny",
    "kind": "StorageBucket",
    "message": "Cloud Storage bucket <tutorial-us-central1-PROJECT_ID>
    uses a disallowed location <us-central1>, allowed locations are
    \"asia-southeast1\", \"asia-southeast2\"",
    "name": "tutorial-us-central1-PROJECT_ID",
    "namespace": "NAMESPACE"
  }
]

    Verás el depósito de Cloud Storage que creaste en us-central1 antes de crear la restricción.

Valida recursos durante el desarrollo

Durante el desarrollo y las compilaciones de integración continua, es útil validar los recursos según las restricciones antes de aplicar esos recursos a tu clúster de GKE. La validación proporciona comentarios rápidos y te permite descubrir problemas relacionados con los recursos y las restricciones de manera anticipada. En estos pasos, se muestra cómo validar recursos con kpt. La herramienta de línea de comandos kpt te permite administrar y aplicar los manifiestos de recursos de Kubernetes.

  1. En Cloud Shell, ejecuta la función de KRM gatekeeper con kpt:

    kpt fn eval . --image=gcr.io/kpt-fn/gatekeeper:v0.2 --truncate-output=false

    Una función de KRM es un programa que puede mutar o validar recursos de Kubernetes almacenados en el sistema de archivos local como archivos YAML. La función gatekeeper de KRM valida los recursos del bucket de Cloud Storage de Config Connector con la política de Gatekeeper. La función gatekeeper de KRM se empaqueta como una imagen de contenedor que está disponible en Artifact Registry.

    La función informa que los archivos de manifiesto de los depósitos de Cloud Storage de las regiones us-central1 y us-west1 infringen la restricción.

    El resultado es similar a este:

    [RUNNING] "gcr.io/kpt-fn/gatekeeper:v0.2"
[FAIL] "gcr.io/kpt-fn/gatekeeper:v0.2"
  Results:
    [ERROR] Cloud Storage bucket <tutorial-us-central1-PROJECT_ID> uses a disallowed location <us-central1>, allowed locations are ["asia-southeast1", "asia-southeast2"] violatedConstraint: singapore-and-jakarta-only in object "storage.cnrm.cloud.google.com/v1beta1/StorageBucket/tutorial/tutorial-us-central1-GOOGLE_CLOUD_PROJECT" in file "tutorial-storagebucket-us-central1.yaml"
    [ERROR] Cloud Storage bucket <tutorial-us-west1-PROJECT_ID> uses a disallowed location <us-west1>, allowed locations are ["asia-southeast1", "asia-southeast2"] violatedConstraint: singapore-and-jakarta-only in object "storage.cnrm.cloud.google.com/v1beta1/StorageBucket/tutorial/tutorial-us-west1-GOOGLE_CLOUD_PROJECT" in file "tutorial-storagebucket-us-west1.yaml"
  Stderr:
    "[error] storage.cnrm.cloud.google.com/v1beta1/StorageBucket/test/tutorial-us-central1-PROJECT_ID : Cloud Storage bucket <tutorial-us-central1-PROJECT_ID> uses a disallowed location <us-central1>, allowed locations are [\"asia-southeast1\", \"asia-southeast2\"]"
    "violatedConstraint: singapore-and-jakarta-only"
    ""
    "[error] storage.cnrm.cloud.google.com/v1beta1/StorageBucket/test/tutorial-us-west1-PROJECT_IDT : Cloud Storage bucket <tutorial-us-west1-PROJECT_IDgt; uses a disallowed location <us-west1>, allowed locations are [\"asia-southeast1\", \"asia-southeast2\"]"
    "violatedConstraint: singapore-and-jakarta-only"
    ""
  Exit code: 1

Valida recursos creados fuera de Config Connector

Puedes validar los recursos Google Cloud que se crearon fuera de Config Connector mediante la exportación de los recursos. Después de exportar los recursos, utiliza cualquiera de las siguientes opciones para evaluar tus políticas de Policy Controller con los recursos exportados:

  • Valida los recursos con la función de KRM gatekeeper.

  • Importa los recursos a Config Connector.

Para exportar los recursos, usa Cloud Asset Inventory.

  1. En Cloud Shell, habilita la API de Cloud Asset:

    gcloud services enable cloudasset.googleapis.com

  2. Borra los archivos de manifiesto del recurso de Kubernetes para los buckets de Cloud Storage en us-central1 y us-west1:

    rm tutorial-storagebucket-us-*.yaml

  3. Exporta todos los recursos de Cloud Storage en tu proyecto actual y almacena el resultado en un archivo llamado export.yaml:

    gcloud beta resource-config bulk-export \
  --project $GOOGLE_CLOUD_PROJECT \
  --resource-format krm \
  --resource-types StorageBucket > export.yaml

    El resultado es similar a este:

    Exporting resource configurations to stdout...

Export complete.

  4. Crea una canalización de kpt encadenando funciones de KRM. Esta canalización valida los recursos en el directorio actual en función de la política de ubicación del bucket de Cloud Storage:

    kpt fn source . \
  | kpt fn eval - --image=gcr.io/kpt-fn/set-namespace:v0.1 -- namespace=NAMESPACE \
  | kpt fn eval - --image=gcr.io/kpt-fn/gatekeeper:v0.2 --truncate-output=false

    Los recursos exportados no tienen un valor para el atributo namespace. Esta canalización usa una función de KRM llamada set-namespace para establecer el valor namespace de todos los recursos.

    El resultado es similar al siguiente y muestra las infracciones de los recursos que exportaste:

    [RUNNING] "gcr.io/kpt-fn/set-namespace:v0.1"
[PASS] "gcr.io/kpt-fn/set-namespace:v0.1"
[RUNNING] "gcr.io/kpt-fn/gatekeeper:v0.2"
[FAIL] "gcr.io/kpt-fn/gatekeeper:v0.2"
  Results:
    [ERROR] Cloud Storage bucket <tutorial-us-central1-PROJECT_ID> uses a disallowed location <us-central1>, allowed locations are ["asia-southeast1", "asia-southeast2"] violatedConstraint: singapore-and-jakarta-only in object "storage.cnrm.cloud.google.com/v1beta1/StorageBucket/tutorial/tutorial-us-central1-GOOGLE_CLOUD_PROJECT" in file "export.yaml"
  Stderr:
    "[error] storage.cnrm.cloud.google.com/v1beta1/StorageBucket/test/tutorial-us-central1-PROJECT_ID : Cloud Storage bucket <tutorial-us-central1-PROJECT_ID> uses a disallowed location <us-central1>, allowed locations are [\"asia-southeast1\", \"asia-southeast2\"]"
    "violatedConstraint: singapore-and-jakarta-only"
    ""
  Exit code: 1

    Si tu proyecto de Google Cloud contiene buckets de Cloud Storage que creaste antes de trabajar en este instructivo y su ubicación infringe la restricción, los buckets creados anteriormente aparecerán en el resultado.

Felicitaciones. Configuraste con éxito una política que regula la ubicación permitida de los depósitos de Cloud Storage. El instructivo está completo. Ahora, puedes continuar agregando tus propias políticas para otros recursos de Google Cloud.

Soluciona problemas

Si Config Connector no crea los recursos Google Cloud esperados, usa el siguiente comando en Cloud Shell para ver los registros del administrador de controladores de Config Connector:

kubectl logs --namespace cnrm-system --container manager \
  --selector cnrm.cloud.google.com/component=cnrm-controller-manager,cnrm.cloud.google.com/scoped-namespace=NAMESPACE

Si Policy Controller no aplica las políticas de forma correcta, usa el siguiente comando para ver los registros del administrador de controladores:

kubectl logs deployment/gatekeeper-controller-manager \
  --namespace gatekeeper-system

Si Policy Controller no informa incumplimientos en el campo status de los objetos de restricción, consulta los registros del controlador de auditoría con este comando:

kubectl logs deployment/gatekeeper-audit --namespace gatekeeper-system

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

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

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

    Go to Manage resources

  2. If the project that you plan to delete is attached to an organization, expand the Organization list in the Name column.
  3. In the project list, select the project that you want to delete, and then click Delete.
  4. In the dialog, type the project ID, and then click Shut down to delete the project.

Borra recursos

Si deseas conservar el proyecto de Google Cloud que usaste en este instructivo, borra los recursos individuales.

  1. En Cloud Shell, borra la restricción de ubicación del depósito de Cloud Storage:

    kubectl delete -f tutorial-storagebucket-location-constraint.yaml

  2. Agrega la anotación cnrm.cloud.google.com/force-destroy con un valor de string de true a todos los recursos storagebucket en el espacio de nombres administrado por Config Connector:

    kubectl annotate storagebucket --all --namespace NAMESPACE \
  cnrm.cloud.google.com/force-destroy=true

    Esta anotación es una directiva que permite a Config Connector borrar un bucket de Cloud Storage cuando borras el recurso storagebucket correspondiente del clúster de GKE, incluso si el bucket contiene objetos.

  3. Borra los recursos de Config Connector que representan los depósitos de Cloud Storage:

    kubectl delete --namespace NAMESPACE storagebucket --all

  4. Borra el clúster de GKE:

    gcloud container clusters delete CLUSTER_NAME \
  --zone ZONE --async --quiet

  5. Borra la vinculación de políticas de Workload Identity en IAM:

    gcloud iam service-accounts remove-iam-policy-binding \
  SERVICE_ACCOUNT_NAME@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com \
  --member "serviceAccount:$GOOGLE_CLOUD_PROJECT.svc.id.goog[cnrm-system/cnrm-controller-manager-NAMESPACE]" \
  --role roles/iam.workloadIdentityUser

  6. Borra la vinculación de la función Administrador de Cloud Storage para la cuenta de servicio de Google:

    gcloud projects remove-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
  --member "serviceAccount:SERVICE_ACCOUNT_NAME@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com" \
  --role roles/storage.admin

  7. Borra la cuenta de servicio de Google que creaste para Config Connector:

    gcloud iam service-accounts delete --quiet \
  SERVICE_ACCOUNT_NAME@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com

¿Qué sigue?