Aller au contenu

Lab 07 : Connexion VPN entre un cluster OKS et un réseau client

À l’issue de ce lab, vous serez capable de :

  • créer une connexion VPN depuis un cluster OKS avec la ressource Kubernetes VpnConnection ;
  • identifier les composants créés par OKS : Client Gateway (passerelle client), Virtual Gateway (passerelle virtuelle) et tunnel IPsec ;
  • récupérer la clé partagée et la configuration de la connexion VPN dans un Secret et un ConfigMap ;
  • configurer un client IPsec strongSwan sur une VM (machine virtuelle) pour établir le tunnel ;
  • tester la connectivité privée entre un Pod du cluster et le réseau client.

Une connexion VPN relie de manière chiffrée un réseau extérieur à OUTSCALE (par exemple le réseau d’une entreprise) à un Net OUTSCALE, à travers Internet. Dans ce lab, le Net relié est celui du projet OKS oks-lab01-project, créé au Lab 01.

Comme au Lab 04 du parcours Architecte, le réseau de l’entreprise est simulé par une VM, oks-lab07-vm-cgw, déployée dans le Cloud public de votre compte. Vous y installez strongSwan : la VM joue le rôle de l’équipement VPN de l’entreprise.

Le Net du projet OKS est géré par OKS : vous ne créez pas vous-même la Virtual Gateway ni la connexion VPN. Vous déclarez la ressource Kubernetes VpnConnection oks-lab07-vpn, et OKS crée pour vous :

  • une Client Gateway, qui décrit l’équipement client, identifié par l’IP publique de la VM ;
  • une Virtual Gateway, attachée au Net du projet OKS ;
  • la connexion VPN à routage statique, avec sa clé partagée (PSK, pre-shared key).

OKS écrit la clé partagée dans le Secret oks-lab07-vpn-secret et la configuration du tunnel dans le ConfigMap oks-lab07-vpn-config, dans le namespace oks-lab07. Vous utilisez ces valeurs pour configurer strongSwan.

Le tunnel est toujours initié par la Client Gateway : tant que strongSwan n’est pas démarré, il reste à l’état DOWN.

Avant de commencer, vous devez disposer :

  • du cluster oks-lab01-cluster à l’état ready, avec ses NodePools, créé dans le Lab 01 ;
  • du fichier oks-lab01-kubeconfig.yaml récupéré dans le Lab 01 ;
  • de kubectl et octl installés et configurés (Lab 01) ;
  • d’un terminal bash ou zsh avec curl, jq et un client SSH. Si jq n’est pas installé : sudo apt install -y jq ;
  • de connaissances sur les connexions VPN OUTSCALE et strongSwan, idéalement acquises au Lab 04 du parcours Architecte.

Le lab utilise la région eu-west-2.

Remarque : les variables du shell (OKS_CIDR, CGW_PUBLIC_IP, etc.) sont perdues si vous fermez votre terminal. Dans ce cas, définissez-les de nouveau avec les commandes des étapes précédentes.

  1. Placez-vous dans le répertoire qui contient le fichier oks-lab01-kubeconfig.yaml, puis indiquez à kubectl de l’utiliser :

    Terminal window
    export KUBECONFIG=$PWD/oks-lab01-kubeconfig.yaml

    Remarque : si vous avez supprimé ce fichier, récupérez-le de nouveau :

    Terminal window
    (umask 077; octl kube cluster kubeconfig oks-lab01-cluster --project oks-lab01-project > oks-lab01-kubeconfig.yaml)
  2. Vérifiez l’accès au cluster :

    Terminal window
    kubectl get nodes
  1. Enregistrez la plage CIDR du Net du projet OKS dans la variable OKS_CIDR :

    Terminal window
    OKS_CIDR=$(octl kube project describe oks-lab01-project -o text --jq '.cidr')
    echo $OKS_CIDR
  2. Enregistrez l’adresse IP publique de votre poste dans la variable MON_IP :

    Terminal window
    MON_IP=$(curl -s -4 https://api.ipify.org)
    echo $MON_IP
  3. Créez le namespace du lab :

    Terminal window
    kubectl create namespace oks-lab07
  1. Créez la paire de clés oks-lab07 et enregistrez sa clé privée :

    Terminal window
    octl iaas keypair create --name oks-lab07 \
    -o text --jq '.PrivateKey' > outscale_oks-lab07.rsa
    chmod 600 outscale_oks-lab07.rsa
  2. Créez le Security Group oks-lab07-sg-cgw dans le Cloud public, et autorisez le SSH depuis votre seule adresse IP :

    Terminal window
    SG_ID=$(octl iaas securitygroup create \
    --name oks-lab07-sg-cgw \
    --description "Lab OKS 07 - VM Client Gateway" \
    -o text --jq '.SecurityGroupId')
    octl iaas securitygrouprule create \
    --group-id $SG_ID \
    --flow Inbound \
    --ports tcp/22 \
    --remote-ranges $MON_IP/32

Remarque : aucune règle entrante n’est nécessaire pour IPsec. C’est la VM qui initie le tunnel, et les Security Groups OUTSCALE sont stateful : les réponses de la Virtual Gateway sont autorisées automatiquement.

  1. Listez les OMI Ubuntu 22.04 publiées par OUTSCALE :

    Terminal window
    octl iaas image list --account-alias Outscale --name 'Ubuntu-22.04-*'

    Repérez la ligne la plus récente (colonne Created On) et copiez son identifiant, qui commence par ami-.

  2. Enregistrez cet identifiant dans la variable IMAGE_ID, en remplaçant ami-08bf5a95 par l’identifiant que vous avez copié, puis vérifiez qu’elle n’est pas vide :

    Terminal window
    IMAGE_ID=ami-08bf5a95
    echo $IMAGE_ID

    Attention : si IMAGE_ID est vide, la commande de création de la VM échoue avec l’erreur does not respect the expected ID prefix 'aki-, ami-, ari-'.

  3. Créez la VM dans le Cloud public :

    Terminal window
    VM_ID=$(octl iaas vm create \
    --image-id $IMAGE_ID \
    --type tinav5.c1r1p2 \
    --keypair-name oks-lab07 \
    --security-group-id $SG_ID \
    --placement-subregion eu-west-2a \
    -o text --jq '.VmId')
    octl iaas tag create --resource-id $VM_ID --key Name --value oks-lab07-vm-cgw
  4. Attendez que la VM soit à l’état running, puis enregistrez ses adresses IP publique et privée :

    Terminal window
    octl iaas vm describe $VM_ID --waitfor '.State=="running"'
    CGW_PUBLIC_IP=$(octl iaas vm describe $VM_ID -o text --jq '.PublicIp')
    CGW_PRIVATE_IP=$(octl iaas vm describe $VM_ID -o text --jq '.PrivateIp')
    echo $CGW_PUBLIC_IP $CGW_PRIVATE_IP

Attention : une VM du Cloud public reçoit une IP publique automatique, qui change si la VM est arrêtée puis redémarrée. Ne l’arrêtez pas pendant le lab : la Client Gateway et la connexion VPN seraient à recréer.

  1. Connectez-vous en SSH à la VM :

    Terminal window
    ssh -i outscale_oks-lab07.rsa outscale@$CGW_PUBLIC_IP
  2. Affichez la table de routage de la VM :

    Terminal window
    ip route

    Exemple de sortie :

    default via 10.9.19.3 dev eth0 proto dhcp src 10.9.19.200 metric 100
    10.9.19.0/24 dev eth0 proto kernel scope link src 10.9.19.200 metric 100
  3. Repérez la ligne qui contient proto kernel scope link : elle indique le CIDR du réseau de la VM, dans cet exemple 10.9.19.0/24. Il représente le réseau de l’entreprise et est noté <CIDR_CLIENT> dans la suite du lab.

  4. Quittez la session SSH :

    Terminal window
    exit
  5. De retour sur votre poste, enregistrez ce CIDR dans une variable, en remplaçant 10.9.19.0/24 par le CIDR relevé sur votre VM, puis vérifiez sa valeur :

    Terminal window
    CIDR_CLIENT=10.9.19.0/24
    echo $CIDR_CLIENT

    Attention : la variable doit être définie sur votre poste, là où vous utilisez kubectl, et non sur la VM : le fichier de la connexion VPN est généré à partir d’elle à l’étape suivante.

Attention : le CIDR du réseau client ne doit pas chevaucher celui du projet OKS (OKS_CIDR). Sinon, le routage entre les deux réseaux est impossible.

  1. Créez le fichier oks-lab07-vpn.yaml à partir des variables du shell :

    Terminal window
    cat > oks-lab07-vpn.yaml <<EOF
    apiVersion: oks.dev/v1beta
    kind: VpnConnection
    metadata:
    name: oks-lab07-vpn
    spec:
    publicIP: $CGW_PUBLIC_IP
    bgpASN: 65000
    staticRoutesOnly: true
    vpnRoutes:
    - $CIDR_CLIENT
    clientGatewayConfigurationStorage:
    namespace: oks-lab07
    configMapName: oks-lab07-vpn-config
    secretName: oks-lab07-vpn-secret
    EOF
    cat oks-lab07-vpn.yaml
    • publicIP : IP publique de la VM, qui devient la Client Gateway.
    • bgpASN : numéro de système autonome (ASN) de la Client Gateway. Il est obligatoire, même si le routage est statique.
    • staticRoutesOnly: true : connexion VPN à routage statique, sans BGP.
    • vpnRoutes : plage(s) CIDR du réseau client, vers lesquelles OKS envoie le trafic dans le tunnel.
    • clientGatewayConfigurationStorage : namespace, ConfigMap et Secret dans lesquels OKS écrit la configuration du tunnel et la clé partagée.
  2. Vérifiez que le fichier contient bien les valeurs de vos variables (et non des lignes vides), puis appliquez-le :

    Terminal window
    kubectl apply -f oks-lab07-vpn.yaml
  1. Affichez la connexion VPN :

    Terminal window
    kubectl get vpnconnections

    Exemple de sortie :

    NAME VPN CONNECTION ID VPN CONNECTION STATE VGW PUBLIC IP TUNNEL STATE TUNNEL STATE DESCRIPTION
    oks-lab07-vpn vpn-2210a74d available 142.44.58.83 DOWN IPSEC IS DOWN

    La connexion VPN est à l’état available et le tunnel est DOWN : c’est normal, strongSwan n’est pas encore démarré.

    Juste après la création, la connexion est à l’état pending, sans IP de Virtual Gateway : relancez la commande jusqu’à l’état available (quelques minutes).

  2. Enregistrez l’IP publique de la Virtual Gateway (colonne VGW PUBLIC IP) dans la variable VGW_IP, en remplaçant 142.44.58.83 par l’IP affichée, puis vérifiez sa valeur :

    Terminal window
    VGW_IP=142.44.58.83
    echo $VGW_IP

Remarque : la Client Gateway, la Virtual Gateway et la connexion VPN sont créées et gérées par OKS. Vous les suivez uniquement à travers la ressource Kubernetes oks-lab07-vpn.

La clé partagée est stockée, encodée en Base64, dans la clé PRE_SHARED_KEY du Secret oks-lab07-vpn-secret.

  1. Décodez et enregistrez la clé partagée dans la variable PSK :

    Terminal window
    PSK=$(kubectl get secret oks-lab07-vpn-secret -n oks-lab07 \
    -o jsonpath='{.data.PRE_SHARED_KEY}' | base64 -d)

Attention : la clé partagée est un secret. Ne l’affichez pas pendant une projection, ne la partagez pas et ne la publiez pas dans un dépôt de code.

  1. Affichez la configuration du tunnel, stockée au format JSON dans la clé CGW_CONFIGURATION_JSON du ConfigMap oks-lab07-vpn-config :

    Terminal window
    kubectl get configmap oks-lab07-vpn-config -n oks-lab07 \
    -o jsonpath='{.data.CGW_CONFIGURATION_JSON}' | jq .
  2. Repérez dans ce JSON :

    • l’IP publique de la Virtual Gateway, identique à VGW_IP ;
    • la version d’IKE et les paramètres de chiffrement des phases 1 (IKE) et 2 (IPsec) : algorithme de chiffrement, algorithme d’intégrité, groupe Diffie-Hellman ;
    • les durées de vie des clés et les paramètres de DPD (Dead Peer Detection).

Important : la configuration strongSwan de l’étape 5 reprend les paramètres de la configuration VPN OUTSCALE utilisés au Lab 04 du parcours Architecte : IKEv1, AES 256 bits, SHA-256, groupe Diffie-Hellman 16 (modp4096). Si le JSON indique d’autres valeurs, adaptez les lignes keyexchange, ike et esp.

  1. Affichez les valeurs à reporter sur la VM :

    Terminal window
    echo "CGW_PRIVATE_IP=$CGW_PRIVATE_IP CGW_PUBLIC_IP=$CGW_PUBLIC_IP CIDR_CLIENT=$CIDR_CLIENT VGW_IP=$VGW_IP OKS_CIDR=$OKS_CIDR"
  2. Connectez-vous en SSH à la VM :

    Terminal window
    ssh -i outscale_oks-lab07.rsa outscale@$CGW_PUBLIC_IP
  3. Installez strongSwan :

    Terminal window
    sudo apt update
    sudo apt install -y strongswan
  1. Ouvrez le fichier de configuration de strongSwan :

    Terminal window
    sudo nano /etc/ipsec.conf
  2. Remplacez son contenu par la configuration suivante. Remplacez uniquement les cinq valeurs entre chevrons par celles affichées à l’étape 5.1 :

    config setup
    uniqueids=yes
    conn oks-lab07
    type=tunnel
    auto=start # strongSwan ouvre le tunnel dès son démarrage
    keyexchange=ikev1 # version d'IKE (à vérifier dans CGW_CONFIGURATION_JSON)
    authby=secret # authentification par clé partagée
    left=<CGW_PRIVATE_IP> # l'adresse IP privée de la VM
    leftid=<CGW_PUBLIC_IP> # l'adresse IP publique de la VM (la Client Gateway)
    leftsubnet=<CIDR_CLIENT> # le CIDR du réseau client, avec son masque
    right=<VGW_IP> # l'IP publique de la Virtual Gateway OKS
    rightsubnet=<OKS_CIDR> # le CIDR du Net du projet OKS
    ike=aes256-sha256-modp4096! # chiffrement de la phase 1
    ikelifetime=28800s
    esp=aes256-sha256-modp4096! # chiffrement de la phase 2
    lifetime=3600s
    dpddelay=30s # vérifie toutes les 30 s que la Virtual Gateway répond
    dpdtimeout=120s
    dpdaction=restart # relance le tunnel si elle ne répond plus
    • leftsubnet et rightsubnet définissent la politique IPsec : tout paquet du réseau client vers le Net du projet OKS est envoyé dans le tunnel, et inversement.
    • L’interface réseau de la VM ne porte que son IP privée (left). L’IP publique (leftid) est celle déclarée dans la Client Gateway.

La clé partagée est dans la variable PSK de votre poste. Vous l’écrivez sur la VM depuis votre poste, sans l’afficher ni la copier à la main.

  1. Quittez la session SSH :

    Terminal window
    exit
  2. Sur votre poste, vérifiez que la variable PSK n’est pas vide (la commande affiche sa longueur, pas sa valeur) :

    Terminal window
    echo ${#PSK}

    Si la commande affiche 0, récupérez de nouveau la clé avec la commande de l’étape 4.1.

  3. Écrivez le fichier /etc/ipsec.secrets de la VM :

    Terminal window
    echo "$CGW_PUBLIC_IP $VGW_IP : PSK \"$PSK\"" | \
    ssh -i outscale_oks-lab07.rsa outscale@$CGW_PUBLIC_IP "sudo tee /etc/ipsec.secrets > /dev/null"
    • La ligne envoyée a le format <IP publique de la Client Gateway> <IP de la Virtual Gateway> : PSK "<clé partagée>".
    • sudo tee écrit cette ligne dans le fichier, qui n’est lisible que par root.
  4. Reconnectez-vous en SSH à la VM :

    Terminal window
    ssh -i outscale_oks-lab07.rsa outscale@$CGW_PUBLIC_IP
  1. Redémarrez strongSwan pour prendre en compte la configuration :

    Terminal window
    sudo systemctl restart strongswan-starter

    Remarque : sous Ubuntu, le service strongswan-starter lit les fichiers /etc/ipsec.conf et /etc/ipsec.secrets.

  2. Vérifiez l’état de la connexion :

    Terminal window
    sudo ipsec statusall

    La section Security Associations doit indiquer une connexion établie, par exemple :

    Security Associations (1 up, 0 connecting):
    oks-lab07[1]: ESTABLISHED 10 seconds ago, <CGW_PRIVATE_IP>[<CGW_PUBLIC_IP>]...<VGW_IP>[<VGW_IP>]
    oks-lab07{1}: INSTALLED, TUNNEL, reqid 1, ESP in UDP SPIs: c8e1d69b_i cc18b4fb_o
    oks-lab07{1}: <CIDR_CLIENT> === <OKS_CIDR>
  3. Quittez la session SSH avec exit.

Conseil : si la connexion reste à l’état CONNECTING, vérifiez en priorité l’adresse <VGW_IP>, la clé partagée et les paramètres de chiffrement, puis consultez les journaux avec sudo journalctl -u strongswan-starter -n 50.

Terminal window
kubectl get vpnconnections

Exemple de sortie :

NAME VPN CONNECTION ID VPN CONNECTION STATE VGW PUBLIC IP TUNNEL STATE TUNNEL STATE DESCRIPTION
oks-lab07-vpn vpn-2210a74d available 142.44.58.83 UP IPSEC IS UP

Le tunnel est à l’état UP. L’état est mis à jour par OKS avec un peu de retard : s’il affiche encore DOWN alors que strongSwan indique ESTABLISHED, relancez la commande après une ou deux minutes.

  1. Lancez un Pod temporaire qui envoie quatre requêtes ICMP à l’IP privée de la VM :

    Terminal window
    kubectl run oks-lab07-test --image=busybox:1.36 --restart=Never --rm -it \
    -- ping -c 4 $CGW_PRIVATE_IP

    Exemple de sortie :

    PING 10.9.19.200 (10.9.19.200): 56 data bytes
    64 bytes from 10.9.19.200: seq=0 ttl=60 time=3.08 ms
    64 bytes from 10.9.19.200: seq=1 ttl=60 time=2.04 ms
    64 bytes from 10.9.19.200: seq=2 ttl=60 time=2.05 ms
    64 bytes from 10.9.19.200: seq=3 ttl=60 time=2.04 ms
    --- 10.9.19.200 ping statistics ---
    4 packets transmitted, 4 packets received, 0% packet loss

    Le Pod joint l’IP privée de la VM : le trafic passe par le tunnel VPN chiffré. Côté OKS, le trafic vers CIDR_CLIENT est envoyé à la Virtual Gateway grâce aux vpnRoutes ; côté client, la politique IPsec de strongSwan renvoie les réponses dans le tunnel.

Pour valider votre lab, vérifiez les points suivants :

  • kubectl get vpnconnections affiche oks-lab07-vpn à l’état available, avec le tunnel UP.
  • Le Secret oks-lab07-vpn-secret et le ConfigMap oks-lab07-vpn-config existent dans le namespace oks-lab07.
  • Sur la VM, sudo ipsec statusall affiche la connexion oks-lab07 à l’état ESTABLISHED, entre CIDR_CLIENT et OKS_CIDR.
  • Le Pod oks-lab07-test reçoit les réponses ICMP de l’IP privée de la VM.
  1. Sur la VM, arrêtez strongSwan, observez l’état du tunnel côté OKS, puis redémarrez strongSwan.
  2. Sur la VM, affichez la politique IPsec installée par strongSwan.

Question : Le Security Group oks-lab07-sg-cgw n’autorise que le SSH depuis votre poste. Pourquoi le Pod peut-il tout de même joindre la VM en ICMP ?

💡 Correction — Arrêt et redémarrage de strongSwan

Sur la VM :

Terminal window
sudo systemctl stop strongswan-starter

Sur votre poste, après une à deux minutes :

Terminal window
kubectl get vpnconnections

Le tunnel repasse à l’état DOWN : c’est toujours la Client Gateway qui initie et maintient le tunnel. Redémarrez strongSwan sur la VM avec sudo systemctl start strongswan-starter, puis vérifiez que le tunnel repasse à l’état UP.

💡 Correction — Politique IPsec
Terminal window
sudo ip xfrm policy

La commande affiche deux politiques, dir out et dir in, entre CIDR_CLIENT et OKS_CIDR : tout paquet qui correspond à ces plages est chiffré et envoyé dans le tunnel, sans route supplémentaire.

💡 Correction — Question du challenge

Le Security Group filtre les paquets extérieurs reçus par la VM. Les requêtes ICMP du Pod arrivent encapsulées et chiffrées dans le tunnel IPsec, dont la VM a elle-même initié l’établissement : ces paquets sont des réponses autorisées par le caractère stateful du Security Group. Les requêtes ICMP ne sont déchiffrées et vues en clair qu’une fois arrivées sur la VM.

Attention : avant de supprimer une ressource, vérifiez qu’elle n’est pas utilisée par d’autres labs.

Ce lab est le dernier du parcours OKS. Si vous prévoyez de suivre les labs avancés OKS, ne supprimez pas les ressources du Lab 01 :

  • le projet OKS oks-lab01-project ;
  • le cluster OKS oks-lab01-cluster et ses NodePools ;
  • le fichier kubeconfig oks-lab01-kubeconfig.yaml.

Dans ce cas, supprimez uniquement les ressources du Lab 07 (étapes 1 à 5 ci-dessous), puis réalisez la fin du nettoyage (étapes 6 à 9) à la fin des labs avancés.

Supprimez les ressources suivantes, dans cet ordre. Confirmez chaque suppression demandée par octl en sélectionnant Yes.

  1. Supprimer la connexion VPN. OKS supprime les ressources qu’il a créées pour elle :

    Terminal window
    kubectl delete -f oks-lab07-vpn.yaml

    Vérifiez ensuite que la connexion VPN n’existe plus :

    Terminal window
    kubectl get vpnconnections

    La commande affiche No resources found.

  2. Supprimer le namespace, avec le Secret et le ConfigMap :

    Terminal window
    kubectl delete namespace oks-lab07
  3. Supprimer la VM (Terminate) :

    Terminal window
    octl iaas vm delete $VM_ID

    Relancez octl iaas vm list jusqu’à ce que la VM oks-lab07-vm-cgw n’apparaisse plus ou soit à l’état terminated.

  4. Supprimer le Security Group :

    Terminal window
    octl iaas securitygroup delete $SG_ID
  5. Supprimer la paire de clés et son fichier, puis vérifiez que oks-lab07 n’apparaît plus dans la liste :

    Terminal window
    octl iaas api DeleteKeypair --KeypairName oks-lab07
    rm outscale_oks-lab07.rsa
    octl iaas keypair list

Fin du parcours OKS : suppression des ressources du Lab 01

Supprimez ensuite les ressources créées au Lab 01 et utilisées par tout le parcours, dans l’ordre suivant :

  1. Supprimer les NodePools du Lab 01. OKS supprime leurs VMs :

    Terminal window
    kubectl delete nodepool oks-lab01-nodepool-cli oks-lab01-nodepool-yaml
  2. Supprimer le cluster :

    Terminal window
    octl kube cluster delete oks-lab01-cluster --project oks-lab01-project

    octl affiche The operation completed successfully dès que la demande de suppression est acceptée, mais OKS met quelques minutes à supprimer le cluster. La suppression est terminée quand octl kube cluster describe oks-lab01-cluster renvoie l’erreur cluster "oks-lab01-cluster" not found.

  3. Supprimer le projet :

    Terminal window
    octl kube project delete oks-lab01-project

    Remarque : si la commande renvoie une erreur 403, le projet contient encore un cluster en cours de suppression. Attendez la fin de l’étape 7, puis relancez la commande.

  4. Supprimer le kubeconfig et réinitialiser le projet par défaut d’octl :

    Terminal window
    rm oks-lab01-kubeconfig.yaml
    octl kube project use