Créer des ressources Google Cloud conformes aux règles

Ce tutoriel explique comment les administrateurs de plate-forme peuvent utiliser les règles Policy Controller pour définir comment créer des ressources Google Cloud à l'aide de Config Connector.

Dans les instructions de ce tutoriel, nous partons du principe que vous possédez des connaissances de base sur Kubernetes ou Google Kubernetes Engine (GKE). Dans ce tutoriel, vous allez définir une règle limitant les emplacements autorisés pour les buckets Cloud Storage.

Policy Controller contrôle, audite et applique la conformité de vos ressources de cluster Kubernetes avec des stratégies liées à la sécurité, aux réglementations ou aux règles métier. Policy Controller est conçu à partir de Gatekeeper, un projet Open Source.

Config Connector crée et gère le cycle de vie des ressources Google Cloud en les décrivant en tant que ressources personnalisées Kubernetes. Pour créer une ressource Google Cloud, vous créez une ressource Kubernetes dans un espace de noms géré par Config Connector. L'exemple suivant montre comment décrire un bucket Cloud Storage à l'aide de Config Connector :

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

Gérer vos ressources Google Cloud à l'aide de Config Connector vous permet de leur appliquer des règles Policy Controller lorsque vous les créez dans votre cluster Google Kubernetes Engine (GKE) Enterprise Edition. Ces règles vous permettent d'empêcher ou de signaler toute action créant ou modifiant des ressources d'une manière qui enfreint vos règles. Par exemple, vous pouvez appliquer une règle limitant les emplacements des buckets Cloud Storage.

Cette approche, basée sur le modèle de ressource Kubernetes (KRM), vous permet d'utiliser un ensemble cohérent d'outils et de workflows pour gérer les ressources Kubernetes et Google Cloud. Ce tutoriel explique comment effectuer les tâches suivantes :

  • Définir des règles régissant vos ressources Google Cloud.
  • Mettre en œuvre des contrôles empêchant les développeurs et les administrateurs de créer des ressources Google Cloud qui enfreignent vos règles.
  • Mettre en œuvre des contrôles permettant d'auditer la conformité de vos ressources Google Cloud existantes avec vos règles., même si vous avez créé ces ressources en dehors de Config Connector.
  • Fournir des retours rapides aux développeurs et aux administrateurs lorsqu'ils créent et mettent à jour des définitions de ressources.
  • Valider la conformité des définitions de ressources Google Cloud vis-à-vis de vos règles avant d'essayer d'appliquer les définitions à un cluster Kubernetes.

Objectifs

  • Créer un cluster Google Kubernetes Engine (GKE) Enterprise qui inclut le module complémentaire Config Connector.
  • Installer Policy Controller.
  • Créer une règle pour limiter les emplacements de bucket Cloud Storage autorisés.
  • Vérifier que la règle empêche la création de buckets Cloud Storage dans des emplacements non autorisés.
  • Évaluer la conformité de la définition de buckets Cloud Storage vis-à-vis des règles lors du développement.
  • Auditer les buckets Cloud Storage existants pour vérifier leur conformité vis-à-vis des règles.

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

  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. Dans Cloud Shell, définissez le projet Google Cloud que vous souhaitez utiliser pour ce tutoriel :

    gcloud config set project PROJECT_ID

    Remplacez PROJECT_ID par l'ID de projet Google Cloud de votre projet. Lorsque vous exécutez cette commande, Cloud Shell crée une variable d'environnement exportée nommée GOOGLE_CLOUD_PROJECT qui contient l'ID de votre projet. Si vous n'utilisez pas Cloud Shell, vous pouvez créer la variable d'environnement à l'aide de cette commande :

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

  5. Activez l'API GKE :

    gcloud services enable container.googleapis.com

  6. Activez l'API Policy Controller :

    gcloud services enable anthospolicycontroller.googleapis.com

  7. Créez un répertoire servant à stocker les fichiers créés pour ce tutoriel :

    mkdir -p ~/cnrm-gatekeeper-tutorial

  8. Accédez au répertoire que vous avez créé :

    cd ~/cnrm-gatekeeper-tutorial

Créer un cluster GKE

  1. Dans Cloud Shell, créez un cluster GKE doté du module complémentaire Config Connector et de Workload Identity :

    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

    Remplacez les éléments suivants :

    • CLUSTER_NAME : nom du cluster que vous souhaitez utiliser pour ce projet, par exemple cnrm-gatekeeper-tutorial.
    • ZONE : une zone Compute Engine proche de votre emplacement, par exemple asia-southeast1-b.

    Le module complémentaire Config Connector installe les définitions de ressources personnalisées (CRD, Custom Resource Definitions) pour les ressources Google Cloud dans votre cluster GKE.

  2. Facultatif : Si vous utilisez un cluster privé dans votre propre environnement, ajoutez une règle de pare-feu qui autorise le plan de contrôle du cluster GKE à se connecter au webhook 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

    Remplacez les éléments suivants :

    • CONTROL_PLANE_CIDR : plage d'adresses IP pour le plan de contrôle du cluster GKE, par exemple 172.16.0.16/28.
    • NODE_TAG : tag appliqué à tous les nœuds de votre cluster GKE.

    Cette règle de pare-feu facultative est nécessaire pour que le webhook Policy Controller fonctionne lorsque votre cluster utilise des nœuds privés.

Configurer Config Connector

Le projet Google Cloud dans lequel vous installez Config Connector est appelé projet hôte. Les projets dans lesquels vous utilisez Config Connector pour gérer les ressources sont appelés projets gérés. Dans ce tutoriel, vous utilisez Config Connector pour créer des ressources Google Cloud dans le même projet que votre cluster GKE, de sorte que le projet hôte et le projet géré constituent le même projet.

  1. Dans Cloud Shell, créez un compte de service Google pour Config Connector :

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

    Remplacez SERVICE_ACCOUNT_NAME par le nom que vous souhaitez utiliser pour ce compte de service, par exemple cnrm-gatekeeper-tutorial. Config Connector utilise ce compte de service Google pour créer des ressources dans votre projet géré.

  2. Attribuez le rôle d'administrateur de l'espace de stockage au compte de service 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

    Dans ce tutoriel, vous devez utiliser le rôle "Administrateur de l'espace de stockage", car vous utilisez Config Connector pour créer des buckets Cloud Storage. Dans votre propre environnement, attribuez les rôles nécessaires pour gérer les ressources Google Cloud que vous souhaitez créer pour Config Connector. Pour en savoir plus sur les rôles prédéfinis, consultez la page Comprendre les rôles dans la documentation IAM.

  3. Créez un espace de noms Kubernetes pour les ressources Config Connector que vous allez créer dans ce tutoriel :

    kubectl create namespace NAMESPACE

    Remplacez NAMESPACE par l'espace de noms Kubernetes que vous souhaitez utiliser dans ce tutoriel (par exemple, tutorial).

  4. Annotez l'espace de noms afin de spécifier le projet Config Connector à utiliser pour créer des ressources Google Cloud (c'est-à-dire le projet géré) :

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

  5. Créez une ressource ConfigConnectorContext qui active Config Connector pour l'espace de noms Kubernetes et l'associe au compte de service Google que vous avez créé :

    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

    Lorsque vous créez la ressource ConfigConnectorContext, Config Connector crée un compte de service Kubernetes et un objet StatefulSet dans l'espace de noms cnrm-system afin de gérer les ressources Config Connector dans votre espace de noms.

  6. Attendez que le pod du contrôleur Config Connect de votre espace de noms soit opérationnel :

    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

    Lorsque le pod est prêt, l'invite Cloud Shell s'affiche. Si le message error: no matching resources found s'affiche, patientez une minute puis réessayez.

  7. Associez votre compte de service Kubernetes Config Connector à votre compte de service Google en créant une liaison de stratégie 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

    Cette liaison permet au compte de service Kubernetes cnrm-controller-manager-NAMESPACE de l'espace de noms cnrm-system d'agir sous l'identité du compte de service Google que vous avez créé.

Installer Policy Controller

Installez Policy Controller en suivant les instructions d'installation.

Définissez un intervalle d'audit de 60 secondes.

Créer une ressource Google Cloud à l'aide de Config Connector

  1. Dans Cloud Shell, créez un fichier manifeste Config Connector qui représente un bucket Cloud Storage dans la région 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. Pour créer le bucket Cloud Storage, appliquez le fichier manifeste :

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

  3. Vérifiez que Config Connector a bien créé le bucket Cloud Storage :

    gsutil ls | grep tutorial

    Le résultat ressemble à ce qui suit :

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

    Ce résultat inclut PROJECT_ID, qui est votre ID de projet Google Cloud.

    Si cette sortie n'apparaît pas, attendez une minute et répétez l'étape.

Créer une règle

Dans Policy Controller, une règle est composée d'un modèle de contrainte et d'une contrainte. Le modèle de contrainte contient la logique de la règle. La contrainte spécifie dans quel contexte la règle s'applique et les paramètres d'entrée associés à la logique de la règle.

  1. Dans Cloud Shell, créez un modèle de contrainte limitant les emplacements autorisés pour les buckets 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. Appliquez le modèle pour créer le bucket Cloud Storage :

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

  3. Créez une contrainte n'autorisant que les buckets dans les régions de Singapour et de Jakarta (asia-southeast1 et asia-southeast2). La contrainte s'applique à l'espace de noms que vous avez créé précédemment. Le bucket Cloud Storage par défaut pour Cloud Build est exempté.

    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. Pour limiter les zones dans lesquelles des buckets peuvent exister, appliquez la contrainte :

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

Valider la règle

  1. Créez un fichier manifeste représentant un bucket Cloud Storage dans un emplacement non autorisé (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. Pour créer le bucket Cloud Storage, appliquez le fichier manifeste :

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

    Le résultat ressemble à ce qui suit :

    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. Facultatif : Vous pouvez afficher un enregistrement de la décision de refus de la requête dans Cloud Audit Logging. Interrogez les journaux d'activité d'administration de votre projet :

    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'

    Le résultat ressemble à ce qui suit :

    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'

    Le champ methodName indique l'opération tentée, resourceName indique le nom complet de la ressource Config Connector et la section status indique que la requête a échoué avec le code d'erreur 7 et le message Forbidden.

  4. Créez un fichier manifeste représentant un bucket Cloud Storage dans un emplacement autorisé (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. Pour créer le bucket Cloud Storage, appliquez le fichier manifeste :

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

    Le résultat ressemble à ce qui suit :

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

    Ce résultat inclut PROJECT_ID, qui est votre ID de projet Google Cloud.

  6. Vérifiez que Config Connector a bien créé le bucket Cloud Storage :

    gsutil ls | grep tutorial

    Le résultat ressemble à ce qui suit :

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

    Si cette sortie n'apparaît pas, attendez une minute et répétez l'étape.

Contraintes d'audit

Le contrôleur d'audit de Policy Controller évalue périodiquement les ressources par rapport à leurs contraintes. Le contrôleur détecte les cas de non-respect des règles pour les ressources créées avant la contrainte et pour les ressources créées en dehors de Config Connector.

  1. Dans Cloud Shell, affichez les cas de non-respect associés à toutes les contraintes utilisant le modèle de contrainte GCPStorageLocationConstraintV1 :

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

    Le résultat ressemble à ce qui suit :

    [
  {
    "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"
  }
]

    Le bucket Cloud Storage que vous avez créé dans la région us-central1 avant de créer la contrainte s'affiche.

Valider les ressources pendant le développement

Au cours du développement et des compilations dans le cadre d'une intégration continue, il est utile de valider les ressources vis-à-vis des contraintes avant d'appliquer ces ressources à votre cluster GKE. La validation permet d'obtenir des retours rapides et de détecter rapidement les problèmes liés aux ressources et aux contraintes. Les étapes ci-dessous vous montrent comment valider les ressources avec kpt. L'outil de ligne de commande kpt vous permet de gérer et d'appliquer les fichiers manifestes de vos ressources Kubernetes.

  1. Dans Cloud Shell, exécutez la fonction KRM gatekeeper à l'aide de kpt :

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

    Une fonction KRM est un programme qui peut muter ou valider des ressources Kubernetes stockées sur le système de fichiers local sous forme de fichiers YAML. La fonction KRM gatekeeper valide les ressources du bucket Cloud Storage Config Connector par rapport à la règle Gatekeeper. La fonction KRM gatekeeper est empaquetée sous forme d'image de conteneur disponible dans Artifact Registry.

    La fonction indique que les fichiers manifestes des buckets Cloud Storage situés dans les régions us-central1 et us-west1 enfreignent la contrainte.

    Le résultat ressemble à ce qui suit :

    [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

Valider les ressources créées en dehors de Config Connector

Vous pouvez valider les ressources Google Cloud créées en dehors de Config Connector en exportant les ressources. Après avoir exporté les ressources, utilisez l'une des options suivantes pour évaluer vos stratégies Policy Controller vis-à-vis des ressources exportées :

  • Validez les ressources à l'aide de la fonction KRM gatekeeper.

  • Importez les ressources dans Config Connector.

Pour exporter les ressources, utilisez l'inventaire des éléments cloud.

  1. Dans Cloud Shell, activez l'API Cloud Asset :

    gcloud services enable cloudasset.googleapis.com

  2. Supprimez les fichiers manifestes des ressources Kubernetes pour les buckets Cloud Storage dans us-central1 et us-west1 :

    rm tutorial-storagebucket-us-*.yaml

  3. Exportez toutes les ressources Cloud Storage de votre projet actuel et stockez les résultats dans un fichier nommé export.yaml :

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

    Le résultat ressemble à ce qui suit :

    Exporting resource configurations to stdout...

Export complete.

  4. Créez un pipeline Kpt en associant des fonctions KRM. Ce pipeline valide les ressources du répertoire actuel par rapport à la stratégie d'emplacement du bucket 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

    Les ressources exportées ne comportent pas de valeur pour l'attribut de métadonnées namespace. Ce pipeline utilise une fonction KRM appelée set-namespace pour définir la valeur namespace de toutes les ressources.

    Le résultat ressemble à ce qui suit et indique des cas de non-respect pour les ressources que vous avez exportées :

    [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 votre projet Google Cloud contient des buckets Cloud Storage que vous avez créés avant de suivre ce tutoriel et dont l'emplacement ne respecte pas la contrainte, ces buckets précédemment créés apparaissent dans le résultat.

Félicitations, vous avez correctement configuré une règle qui régit les emplacements autorisés pour les buckets Cloud Storage. Le tutoriel est terminé. Vous pouvez maintenant continuer à ajouter vos propres règles pour d'autres ressources Google Cloud.

Dépannage

Si Config Connector ne crée pas les ressources Google Cloud attendues, exécutez la commande suivante dans Cloud Shell pour afficher les journaux du gestionnaire de contrôleurs 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 n'applique pas correctement les règles, utilisez la commande suivante pour afficher les journaux du gestionnaire de contrôleurs :

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

Si Policy Controller ne signale pas de violation dans le champ status des objets de contrainte, affichez les journaux du contrôleur d'audit à l'aide de la commande suivante :

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

Si vous rencontrez d'autres problèmes avec ce tutoriel, nous vous recommandons de consulter les documents ci-dessous :

Nettoyer

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer le projet

  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.

Supprimer les ressources

Si vous souhaitez conserver le projet Google Cloud que vous avez utilisé dans ce tutoriel, supprimez les différentes ressources.

  1. Dans Cloud Shell, supprimez la contrainte d'emplacement des buckets Cloud Storage :

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

  2. Ajoutez l'annotation cnrm.cloud.google.com/force-destroy avec une valeur de chaîne de true à toutes les ressources storagebucket de l'espace de noms géré par Config Connector :

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

    Cette annotation est une directive qui autorise Config Connector à supprimer un bucket Cloud Storage lorsque vous supprimez la ressource storagebucket correspondante du cluster GKE, même si le bucket contient des objets.

  3. Supprimez les ressources Config Connector qui représentent les buckets Cloud Storage :

    kubectl delete --namespace NAMESPACE storagebucket --all

  4. Supprimez le cluster GKE :

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

  5. Supprimez la liaison de stratégie Workload Identity dans 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. Supprimez la liaison du rôle d'administrateur Cloud Storage pour le compte de service 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. Supprimez le compte de service Google que vous avez créé pour Config Connector :

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

Étape suivante