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éterminer comment créer des ressources Google Cloud à l'aide de Config Connector.

Les instructions de ce tutoriel supposent 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 comme des ressources Kubernetes personnalisées. 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

En gérant vos ressources Google Cloud avec Config Connector, vous pouvez appliquer des règles Policy Controller à ces ressources lorsque vous les créez dans votre cluster Google Kubernetes Engine (GKE) Enterprise. 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 incluant le module complémentaire Config Connector
Installez 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

Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

Accéder au sélecteur de projet
Vérifiez que la facturation est activée pour votre projet Google Cloud.
Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell
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 appelé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)
```

Activez l'API GKE :

gcloud services enable container.googleapis.com

Créez un répertoire servant à stocker les fichiers créés pour ce tutoriel :
```
mkdir -p ~/cnrm-gatekeeper-tutorial
```
Accédez au répertoire que vous avez créé :
```
cd ~/cnrm-gatekeeper-tutorial
```

Créer un cluster GKE

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

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é.
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.
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 le tutoriel, par exemple, tutorial.
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
```
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.
Attendez le pod du contrôleur Config Connector pour votre espace de noms:
```
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.
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

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

Pour créer le bucket Cloud Storage, appliquez le fichier manifeste:
```
kubectl apply -f tutorial-storagebucket-us-central1.yaml
```
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 l'ID de votre projet Google Cloud.

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

Créer une règle

Une règle dans Policy Controller se compose 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.

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

Appliquez le modèle pour créer le bucket Cloud Storage :

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

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

Pour limiter les zones dans lesquelles les buckets peuvent exister, appliquez la contrainte:
```
kubectl apply -f tutorial-storagebucket-location-constraint.yaml
```

Vérifier la stratégie

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

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"]

Facultatif: Vous pouvez consulter un enregistrement de la décision de refuser la requête dans Cloud Audit Logs. 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.

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

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 l'ID de votre projet Google Cloud.
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 régulièrement 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.

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.

Remarque :L'attribut status.violations par défaut affiche jusqu'à 20 cas de non-respect par contrainte. Si le contrôleur d'audit détecte plus de 20 cas de non-respect des contraintes, les autres ne s'affichent pas. Si vous atteignez cette limite dans votre propre environnement, créez plusieurs contraintes. Limitez chaque contrainte à un espace de noms différent.

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.

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 modifier ou valider des ressources Kubernetes stockées dans le système de fichiers local en tant que 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 la forme d'une 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.

Dans Cloud Shell, activez l'API Cloud Asset :

gcloud services enable cloudasset.googleapis.com

Supprimez les fichiers manifestes des ressources Kubernetes pour les buckets Cloud Storage dans us-central1 et us-west1 :
```
rm tutorial-storagebucket-us-*.yaml
```

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.

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 affiche des cas de non-respect des règles 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 que leur emplacement ne respecte pas la contrainte, les buckets créés précédemment 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 prévues, utilisez la commande suivante dans Cloud Shell pour afficher les journaux du gestionnaire de contrôleurs 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 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 les cas de non-respect 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 :

Effectuer un nettoyage

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

Attention : La suppression d'un projet aura les effets suivants :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches de ce document, lorsque vous le supprimez, vous supprimez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

Dans la console Google Cloud, accédez à la page Gérer les ressources.
Accéder à la page Gérer les ressources
Si le projet que vous envisagez de supprimer est associé à une organisation, développez la liste Organisation dans la colonne Nom.
Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer les ressources

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

Dans Cloud Shell, supprimez la contrainte d'emplacement des buckets Cloud Storage :
```
kubectl delete -f tutorial-storagebucket-location-constraint.yaml
```
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.
Supprimez les ressources Config Connector qui représentent les buckets Cloud Storage:
```
kubectl delete --namespace NAMESPACE storagebucket --all
```

Supprimez le cluster GKE :

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

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

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

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

Étapes suivantes

Découvrez comment signaler les cas de non-respect d'audit de Policy Controller dans Security Command Center.
Découvrez comment exécuter la validation Policy Controller dans le cadre d'un pipeline d'intégration continue dans Cloud Build.