15 min de lecture

Objectifs d'apprentissage

À la fin de ce module, vous serez en mesure de:

  • Automatiser la rotation des jetons API avec l'API Auth : émettre, vérifier, stocker et révoquer les jetons par service et par environnement
  • Gérer les utilisateurs, les groupes, les privilèges et les parts de ressources de TaskBoard à l'aide de `ionoscloud_user`, `ionoscloud_group` et `ionoscloud_share`
  • Fournir les identifiants de base de données issus des sorties Terraform dans des Secrets Kubernetes sans les commettre nulle part
  • Exécuter les règles NSG via le pipeline d'infrastructure avec détection de dérive, et protéger les charges de travail MKS là où les NSG ne s'appliquent pas
  • Distribuer et faire tourner les clés SSH pour les serveurs Linux à l'aide de Terraform et de cloud-init

Unité 5.2 : Automatisation de la sécurité

Introduction

TaskBoard dispose désormais d'un utilisateur CI doté d'un jeton Cloud API, d'un jeton de récupération (pull) pour le registre, de clés Object Storage, de deux mots de passe de base de données et d'un accès SSH à la VM de travail. Chacun de ces éléments a été créé une seule fois, manuellement, et personne ne se souvient de la date. C'est ainsi que les identifiants finissent par fuir : un jeton d'un collègue parti, un mot de passe dans un fichier .tfvars, une règle de pare-feu qu'une personne a activée dans le DCD lors d'un incident.

Dans cette unité, vous transformez la sécurité en code exécuté selon un planning. Vous faites tourner les jetons API via l'API Auth, modélisez l'accès à l'aide d'utilisateurs et de groupes gérés par Terraform, alimentez les Secrets Kubernetes à partir des sorties Terraform, maintenez les règles NSG dans le pipeline et gérez les clés SSH de la manière dont IONOS CLOUD les injecte. Dans le Code Lab, vous faites tourner le jeton CI de TaskBoard, ajoutez une règle NSG via Terraform et reliez les identifiants PostgreSQL à un Secret Kubernetes.

1. Automatisation du cycle de vie des jetons API

1.1 Inventaire avant rotation

curl --silent "https://api.ionos.com/auth/v1/tokens" \
  --header "Authorization: Bearer $IONOS_TOKEN" \
  | jq -r '.tokens[] | "\(.id)  created \(.createdDate)  expires \(.expirationDate)"'

GET /tokens répertorie les jetons de l'utilisateur authentifié avec id, createdDate et expirationDate. Les utilisateurs disposant de plusieurs contrats ajoutent l'en-tête X-Contract-Number. La valeur du jeton elle-même n'apparaît plus jamais : le Token Manager l'affiche uniquement une fois, lors de sa génération. Un utilisateur peut détenir jusqu'à 100 jetons, de sorte qu'une tâche de rotation qui ne supprime jamais les anciens jetons finira par échouer.

1.2 Une tâche de rotation

Chaque service dispose de son propre utilisateur IONOS CLOUD (section 2), et la tâche de rotation s'exécute avec le jeton actuel de cet utilisateur :

import base64
import json
import os
import subprocess

import requests

AUTH = "https://api.ionos.com/auth/v1"
TTL = 30 * 24 * 3600  # seconds; the API accepts 60 to 31536000


def key_id(jwt: str) -> str:
    header = jwt.split(".")[0]
    header += "=" * (-len(header) % 4)
    return json.loads(base64.urlsafe_b64decode(header))["kid"]


def main() -> None:
    old = os.environ["IONOS_TOKEN"]
    resp = requests.get(f"{AUTH}/tokens/generate", params={"ttl": TTL},
                        headers={"Authorization": f"Bearer {old}"}, timeout=30)
    resp.raise_for_status()
    new = resp.json()["token"]
    auth_new = {"Authorization": f"Bearer {new}"}

    # 1. prove the new token works before anything depends on it
    requests.get("https://api.ionos.com/cloudapi/v6/datacenters", params={"depth": 0},
                 headers=auth_new, timeout=30).raise_for_status()

    # 2. store it (stdin, so the value never appears in the process list)
    subprocess.run(["gh", "secret", "set", "IONOS_TOKEN"], input=new, text=True, check=True)

    # 3. revoke the old token by its key ID, then remove expired tokens
    requests.delete(f"{AUTH}/tokens/{key_id(old)}", headers=auth_new, timeout=30).raise_for_status()
    requests.delete(f"{AUTH}/tokens", params={"criteria": "EXPIRED"},
                    headers=auth_new, timeout=30).raise_for_status()
    print("rotated, new token expires in", TTL // 86400, "days")


if __name__ == "__main__":
    main()

Le paramètre path de DELETE /tokens/{tokenId} est l'identifiant de clé (Key ID) de la section d'en-tête du jeton. La suppression d'un jeton le désactive immédiatement, même avant son expiration, l'ordre est donc important : générer, vérifier, stocker, puis révoquer. Les utilisateurs ayant l'authentification à deux facteurs (2FA) doivent utiliser des jetons sécurisés par 2FA pour supprimer des jetons ; l'rotation doit être effectuée sous des comptes de service dédiés.

1.3 Planification et nettoyage

Enregistrez la tâche sous le nom .github/workflows/rotate-token.yml :

on:
  schedule:
    - cron: "0 3 * * 1"
jobs:
  rotate:
    runs-on: ubuntu-latest
    environment: production
    steps:
      - uses: actions/checkout@v4
      - run: pip install requests && python ops/rotate_token.py
        env:
          IONOS_TOKEN: ${{ secrets.IONOS_TOKEN }}
          GH_TOKEN: ${{ secrets.SECRETS_ADMIN_PAT }}

Une tâche hebdomadaire avec un ttl de 30 jours laisse suffisamment de marge pour une exécution échouée. L'appel final du script utilise criteria=EXPIRED, qui supprime les jetons expirés pour le contrat. Les autres valeurs sont ALL et CURRENT, il ne faut donc jamais construire ce paramètre à partir d'une entrée. GH_TOKEN doit être autorisé à écrire les secrets du dépôt ; le jeton de flux de travail par défaut ne l'est pas.

2. IAM en tant que code

2.1 Utilisateurs et groupes par service

Les droits dans IONOS CLOUD sont attribués par le biais de groupes. Un groupe détient des privilèges, et un utilisateur les hérite de tous les groupes auxquels il appartient :

resource "ionoscloud_group" "taskboard_ci" {
  name                           = "taskboard-ci"
  create_datacenter              = false
  create_k8s_cluster             = true
  create_network_security_groups = true
  access_and_manage_monitoring   = true
  access_and_manage_logging      = true
  manage_dbaas                   = true
}

resource "ionoscloud_user" "taskboard_ci" {
  first_name          = "taskboard"
  last_name           = "ci"
  email               = "taskboard-ci@example.com"
  password_wo         = random_password.ci.result
  password_wo_version = "1"
  administrator       = false
  force_sec_auth      = false
  active              = true
  group_ids           = [ionoscloud_group.taskboard_ci.id]
}

resource "random_password" "ci" {
  length  = 24
  special = true
}

password_wo est en écriture seule : il n'est pas enregistré dans l'état, requiert Terraform 1.11 ou une version ultérieure, et est mis à jour lorsque vous augmentez password_wo_version. Conservez administrator = false pour chaque utilisateur de service. Les administrateurs n'ont pas besoin d'être gérés dans des groupes, car ils disposent automatiquement d'un accès à toutes les ressources du contrat, de sorte qu'un jeton d'administrateur annule tout autre contrôle de cette unité.

2.2 Partage des ressources

Les privilèges permettent à un groupe de créer des ressources. L'accès aux ressources existantes provient des parts :

resource "ionoscloud_share" "ci_datacenter" {
  group_id        = ionoscloud_group.taskboard_ci.id
  resource_id     = ionoscloud_datacenter.taskboard.id
  edit_privilege  = true
  share_privilege = false
}

resource "ionoscloud_share" "ci_cluster" {
  group_id        = ionoscloud_group.taskboard_ci.id
  resource_id     = ionoscloud_k8s_cluster.taskboard.id
  edit_privilege  = true
  share_privilege = false
  depends_on      = [ionoscloud_share.ci_datacenter]
}

Les parts contrôlent l'accès aux centres de données, aux instantanés, aux images, aux blocs IP, aux Cross Connects, aux unités de sauvegarde et aux clusters Kubernetes, avec trois niveaux d'autorisation : Read, Edit et Sharing. La lecture est implicite dès qu'un groupe est assigné à une ressource. La création de plusieurs parts simultanément entraîne une erreur, c'est pourquoi la deuxième part utilise depends_on ; terraform apply -parallelism=1 est l'alternative.

Pour TaskBoard, utilisez un groupe par service et par environnement : taskboard-ci-dev avec des droits de modification sur le centre de données de développement uniquement, taskboard-ci-prod sur la production, et un groupe en lecture seule taskboard-monitor pour les scripts tels que le récupérateur du Journal d'activité de l'Unité 5.1, qui a également besoin de access_activity_log = true.

3. Secrets Kubernetes issus des sorties Terraform

3.1 Le modèle de pipeline

L'unité 2.5 a maintenu le mot de passe PostgreSQL hors de l'état Terraform à l'aide d'un argument en écriture seule et n'a exporté que l'hôte. La tâche de déploiement combine les deux pour créer un Secret :

PGHOST="$(terraform -chdir=infra output -raw pg_host)"

kubectl -n taskboard create secret generic taskboard-db \
  --from-literal=PGHOST="$PGHOST" \
  --from-literal=PGUSER=taskboard \
  --from-literal=PGPASSWORD="$TF_VAR_pg_password" \
  --from-literal=PGSSLMODE=verify-full \
  --dry-run=client -o yaml | kubectl apply -f -

--dry-run=client -o yaml | kubectl apply rend l'étape idempotente, de sorte que le même job crée ou met à jour le Secret. Rien n'est écrit sur le disque ni dans Git. Évitez le fournisseur Terraform pour Kubernetes pour les identifiants que vous avez délibérément exclus de l'état : une resource Secret stocke ses données dans le fichier d'état.

3.2 Secrets externes et rotation

Lorsque le mot de passe est stocké dans un coffre-fort de secrets, laissez le cluster le récupérer au lieu de le pousser depuis la CI :

apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: taskboard-db
  namespace: taskboard
spec:
  refreshInterval: 1h
  secretStoreRef:
    kind: ClusterSecretStore
    name: vault
  target:
    name: taskboard-db
  data:
    - secretKey: PGPASSWORD
      remoteRef: { key: secret/taskboard/prod, property: pg_password }

La rotation comporte donc trois étapes : écrire le nouveau mot de passe dans le magasin, appliquer Terraform avec password_version incrémenté de un, et redémarrer les pods avec kubectl rollout restart deploy/taskboard-api après que l'opérateur a actualisé le Secret. Les variables d'environnement ne sont lues qu'au démarrage du conteneur. Sur MKS, le chiffrement des données du Secret au repos peut être activé et configuré.

4. Automatisation des NSG dans le pipeline

4.1 Les règles en tant que données

L'unité 2.3 a présenté ionoscloud_nsg et ionoscloud_nsg_firewallrule. En production, décrivez les règles en tant que données afin qu'une demande d'extraction montre exactement quel port s'ouvre pour quelle source :

variable "app_ingress" {
  type = map(object({ source_ip = string, port = number }))
  default = {
    http-from-alb = { source_ip = "10.10.1.6", port = 80 }
  }
}

resource "ionoscloud_nsg_firewallrule" "app" {
  for_each         = var.app_ingress
  datacenter_id    = ionoscloud_datacenter.taskboard.id
  nsg_id           = ionoscloud_nsg.app.id
  name             = each.key
  type             = "INGRESS"
  protocol         = "TCP"
  source_ip        = each.value.source_ip
  port_range_start = each.value.port
  port_range_end   = each.value.port
}

Le groupe de l'utilisateur CI a besoin de create_network_security_groups. protocol ne peut pas être modifié après la création ; le modifier impose une nouvelle règle.

4.2 Détection de dérive

Une règle activée dans DCD pendant un incident subsiste jusqu'à ce que quelqu'un la remarque. Un plan planifié le fait à votre place :

terraform plan -input=false -detailed-exitcode -lock=false > drift.txt
case $? in
  0) echo "no drift" ;;
  2) echo "drift detected"; gh issue create --title "NSG drift" --body-file drift.txt ;;
  *) echo "plan failed"; exit 1 ;;
esac

Un code de sortie 2 signifie que la configuration réelle diffère du code. Résolvez ce problème en modifiant le code et en appliquant les changements, et non en laissant la modification manuelle en place.

4.3 Les limites de portée des NSG

Les membres d'un NSG sont des VM et des NIC. L'ALB et le NLB ne sont pas des membres, et les nœuds des pools de nœuds Managed Kubernetes sont exclus des NSG. Pour le trafic entre pods sur MKS, utilisez les Kubernetes NetworkPolicies, que le plugin CNI Calico sur MKS prend en charge :

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-from-ingress-only
  namespace: taskboard
spec:
  podSelector: { matchLabels: { app: taskboard-api } }
  policyTypes: [Ingress]
  ingress:
    - from:
        - namespaceSelector: { matchLabels: { kubernetes.io/metadata.name: ingress } }
      ports:
        - { port: 8000, protocol: TCP }

5. Clés SSH

5.1 Injection lors de la provision

variable "team_ssh_keys" {
  type = list(string)   # public keys, one per team member
}

resource "ionoscloud_vcpu_server" "worker" {
  # ... arguments and volume from Unit 2.1 ...
  image_name = data.ionoscloud_image.ubuntu.id
  ssh_keys   = var.team_ssh_keys
}

L'API Cloud injecte les clés publiques lorsqu'un volume est créé à partir d'une image IONOS CLOUD Linux ; les images Windows, les instantanés, les images privées et les images MS SQL ne prennent pas en charge l'injection. ssh_keys est immuable et ne peut être défini qu'au moment de la création. Les clés enregistrées dans le SSH Key Manager du DCD (jusqu'à 100 par utilisateur) constituent une commodité du DCD ; l'API Cloud ne gère pas ce magasin, il convient donc de conserver la liste des clés de l'équipe dans le code.

5.2 Rotation

Étant donné que les clés injectées ne peuvent pas être modifiées sur un serveur en cours d'exécution, gérez authorized_keys avec cloud-init (Unité 2.1) pour les nouveaux serveurs et avec votre outil de gestion de configuration pour les serveurs en cours d'exécution :

#cloud-config
users:
  - name: deploy
    groups: [sudo]
    shell: /bin/bash
    ssh_authorized_keys:
      - ssh-ed25519 AAAA... alice@taskboard
      - ssh-ed25519 AAAA... bob@taskboard

Pour supprimer la clé d'un collègue ayant quitté l'entreprise, supprimez-la de la variable, redéployez de nouvelles VM de travailleur ou exécutez le travail de configuration, puis vérifiez avec ssh-keygen -lf sur le serveur.

Fiche de référence rapide de l'API

Principaux points de terminaison de l'API pour le sujet de cette unité :

Méthode Point de terminaison Description
GET https://api.ionos.com/auth/v1/tokens/generate?ttl=<seconds> Générer un nouveau jeton
GET https://api.ionos.com/auth/v1/tokens Lister les jetons de l'utilisateur
DELETE https://api.ionos.com/auth/v1/tokens/{tokenId} Révoquer un jeton par identifiant de clé
DELETE https://api.ionos.com/auth/v1/tokens?criteria=EXPIRED Supprimer les jetons expirés
POST /datacenters/{datacenterId}/securitygroups/{securityGroupId}/rules Ajouter une règle NSG

URL de base : https://api.ionos.com/cloudapi/v6 (API d'authentification telle qu'indiquée) Authentification : Authorization: Bearer <token>

Atelier de code

Objectif : Faire pivoter le jeton CI de TaskBoard, ajouter une règle NSG via Terraform et intégrer les identifiants PostgreSQL dans un Secret Kubernetes.

Prérequis :

  • Un utilisateur CI dédié et son jeton dans IONOS_TOKEN
  • Le projet Terraform avec le NSG de l'unité 2.3 et PostgreSQL de l'unité 2.5
  • Accès kubectl à l'espace de noms TaskBoard, jq, gh et Python 3 avec requests

Étape 1 : Lister les jetons actuels

curl --silent "https://api.ionos.com/auth/v1/tokens" -H "Authorization: Bearer $IONOS_TOKEN" | jq '.tokens | length'

Sortie attendue :

3

Étape 2 : Faire pivoter le jeton

python ops/rotate_token.py

Sortie attendue :

✓ Set Actions secret IONOS_TOKEN for <org>/taskboard
rotated, new token expires in 30 days

Étape 3 : Confirmer que l'ancien jeton a été révoqué

curl --silent -o /dev/null -w "%{http_code}\n" \
  "https://api.ionos.com/cloudapi/v6/datacenters" -H "Authorization: Bearer $IONOS_TOKEN"

Sortie attendue :

401

Chargez la nouvelle valeur depuis votre magasin de secrets dans IONOS_TOKEN avant de continuer.

Étape 4 : Ajouter une règle NSG via une demande d'extraction

Ajoutez ssh-from-vpn = { source_ip = "10.10.9.10", port = 22 } à var.app_ingress (section 4.1), poussez une branche et ouvrez une demande d'extraction.

terraform plan

Sortie attendue :

  # ionoscloud_nsg_firewallrule.app["ssh-from-vpn"] will be created
Plan: 1 to add, 0 to change, 0 to destroy.

Étape 5 : Vérifier les dérives

Après la fusion et l'application, exécutez le script de la section 4.2. Sortie attendue :

no drift

Étape 6 : Créer le Secret de base de données

export TF_VAR_pg_password="$(vault kv get -field=pg_password secret/taskboard/dev)"
bash ops/db-secret.sh    # the commands from Section 3.1
kubectl -n taskboard get secret taskboard-db -o jsonpath='{.data.PGHOST}' | base64 -d

Sortie attendue :

secret/taskboard-db configured
<cluster-dns-name>

Liste de contrôle de validation :

  • [ ] L'ancien jeton renvoie 401, le nouveau fonctionne depuis CI
  • [ ] La règle NSG n'existe que parce qu'une demande d'extraction a été fusionnée
  • [ ] La vérification de dérive ne signale aucune dérive
  • [ ] taskboard-db existe dans le cluster et dans aucun fichier de Git

Nettoyage :

unset TF_VAR_pg_password
history -c

Conservez le flux de travail de rotation ; supprimez la règle ssh-from-vpn dans une autre demande d'extraction si vous n'utilisez pas le VPN.

Erreurs courantes

Erreurs de développement à éviter concernant le sujet de cette unité :

  1. Révocation avant stockage

    • Problème : Le travail de rotation supprime l'ancien jeton, puis échoue à écrire le nouveau, et tous les pipelines renvoient 401.
    • Pourquoi cela se produit : La suppression prend effet immédiatement, et la valeur du nouveau jeton n'est affichée qu'une seule fois.
    • Correction : Générez, vérifiez et stockez d'abord, supprimez en dernier (Section 1.2) ; conservez une procédure d'urgence pour émettre un jeton avec le mot de passe de l'utilisateur.
  2. Jetons de service depuis un compte administrateur

    • Problème : Un jeton CI divulgué supprime des ressources dans une portée couvrant l'ensemble du contrat.
    • Pourquoi cela se produit : Les administrateurs ont accès à toutes les ressources du contrat, indépendamment des groupes et des parts.
    • Correction : Créez un utilisateur non administrateur par service et par environnement, accordez les privilèges via un groupe et l'accès aux ressources via ionoscloud_share.
  3. S'attendre à ce que les NSG isolent les pods

    • Problème : Vous ajoutez une règle NSG pour le port de la base de données, mais les pods sur MKS continuent de se joindre sur tous les ports.
    • Pourquoi cela se produit : Les nœuds du pool de nœuds Managed Kubernetes sont exclus des NSG.
    • Correction : Utilisez les NetworkPolicies Kubernetes pour le trafic des pods (Section 4.3) et les NSG pour les VM et leurs NIC.

Résumé

Vous pouvez désormais exécuter les identifiants et les règles d'accès de TaskBoard sous forme de code. Les jetons sont renouvelés selon un planning avec une courte ttl, les utilisateurs de service ne reçoivent que les privilèges et les partages dont ils ont besoin, les mots de passe des bases de données proviennent du coffre-fort de secrets et sont injectés dans Kubernetes sans passer par Git ni par l'état, les règles NSG ne sont modifiées que par des demandes de fusion avec détection de dérive, et l'accès SSH suit la liste des clés d'équipe définie dans le code.

Points clés :

  • Renouveler les jetons dans l'ordre : générer, vérifier, stocker, révoquer ; la suppression est immédiate
  • Un utilisateur non administrateur par service et par environnement, droits via les groupes, accès via les partages
  • Alimenter les Secrets Kubernetes à partir des sorties Terraform et du coffre-fort de secrets, jamais à partir de fichiers dans Git
  • Les NSG couvrent les VM et les NIC ; utiliser des NetworkPolicies pour les pods sur MKS
  • Les clés SSH injectées sont immuables ; gérer le renouvellement avec cloud-init et la gestion de configuration

Terminologie importante :

  • Key ID : L'identifiant du jeton dans l'en-tête JWT, utilisé par DELETE /tokens/{tokenId}
  • Privilege : Un droit de groupe tel que create_k8s_cluster qui permet de créer un type de ressource
  • Share : L'accès d'un groupe à une ressource existante via Read, Edit ou Sharing
  • Argument en écriture seule : Un argument Terraform tel que password_wo qui n'est jamais stocké dans l'état
  • Drift : Une différence entre la configuration réelle et le code, détectée avec plan -detailed-exitcode

Prochaines étapes

Continuer l'apprentissage : Unité 5.3 : GitOps et opérations de déploiement

Sujets connexes :