For AI agents: the complete documentation index is available at https://docs.ovhcloud.com/fr/llms.txt, the full documentation bundle is available at https://docs.ovhcloud.com/fr/llms-full.txt, and this page is available as Markdown at https://docs.ovhcloud.com/fr/guides/public-cloud/containers-orchestration/managed-kubernetes/vrack-custom-gateway.md.
Aller au contenu

Utiliser une passerelle personnalisée sur un cluster OVHcloud Managed Kubernetes

Voir en Markdown

Découvrez comment utiliser une passerelle personnalisée sur OVHcloud Managed Kubernetes, avec votre routeur ou pare-feu (plan Standard) ou une passerelle vRack (plan Free)

Objectif

Une passerelle personnalisée vous permet de contrôler la façon dont les nœuds de votre cluster OVHcloud Managed Kubernetes accèdent à Internet : par exemple pour disposer d'une seule adresse IP de sortie à autoriser chez vos partenaires, ou pour faire passer tout le trafic de vos nœuds par votre propre pare-feu afin de l'inspecter, de le filtrer et de le journaliser (architecture hub-and-spoke).

La méthode dépend du plan de votre cluster :

Plan StandardPlan Free
Sortie Internet par défaut des nœudsVia une passerelle managée OVHcloud (une IP de sortie partagée), ou via des Floating IP définies au niveau du pool de nœudsVia l'adresse IP publique de chaque nœud
Passerelle personnaliséeVotre propre routeur ou pare-feu, défini comme passerelle du sous-réseau des nœuds (useUserGateway)Une passerelle dans votre vRack, utilisée comme route par défaut (privateNetworkRoutingAsDefault et defaultVrackGateway)
Passerelle managée OVHcloud nécessaireNon, lorsque vous utilisez votre propre routeurSans objet
Exposition publique des nœuds et des workloadsDésactivée lorsque vous utilisez votre propre routeur : ni Floating IP, ni Load Balancer publicInchangée
Moment de la configurationÀ la création du cluster uniquement, non modifiable ensuiteÀ la création ou à la réinitialisation du cluster
Info

Sur tout nouveau cluster Standard, le trafic entre les nœuds et le control plane Kubernetes passe par un chemin privé opéré par OVHcloud. Le fonctionnement du cluster ne dépend pas de votre passerelle : une modification ou une panne de votre routeur n'affecte pas la communication entre les nœuds et le control plane.


Accès à la console OVHcloud

  • Lien direct :
  • Pour accéder à vos services : Public Cloud > Sélectionnez votre projet > Conteneurs > Managed Kubernetes Service

Utiliser votre propre routeur ou pare-feu (plan Standard)

Fonctionnement

Avec le plan Standard, les nœuds n'ont pas d'IP publique par défaut : ils accèdent à Internet via une passerelle managée OVHcloud, ou via des Floating IP définies au niveau du pool de nœuds.

Les clusters Standard créés depuis le 13 octobre 2026, quelle que soit leur version de Kubernetes, peuvent à la place utiliser votre propre routeur ou pare-feu comme passerelle par défaut des nœuds. C'est l'architecture hub-and-spoke classique : votre appliance de sécurité est le hub, et le cluster est l'un des spokes. Votre appliance est la passerelle annoncée sur le sous-réseau des nœuds de votre réseau privé : le trafic sortant des nœuds passe par elle (sauf le trafic vers le control plane et les images système du service), et aucune passerelle managée OVHcloud n'est nécessaire.

Ce que cela implique pour le cluster :

  • Votre appliance porte le trafic sortant des workloads : accès à Internet, aux autres réseaux, aux ressources on-premises. Les pods sortent avec l'adresse privée de leur nœud : vos règles de pare-feu voient donc des adresses de nœuds, et non des adresses de pods.
  • Elle n'est pas sur le chemin du cluster lui-même : les nœuds joignent le control plane Kubernetes via un chemin privé opéré par OVHcloud, et les images système du service ne passent pas par votre appliance. Si votre appliance est indisponible, le cluster continue de fonctionner, mais vos workloads qui dépendent d'elle, par exemple pour accéder à Internet ou à d'autres ressources externes, sont affectés.
  • L'exposition publique des nœuds et des workloads est désactivée : aucune Floating IP ne peut être attachée aux nœuds ni aux load balancers, et aucun Load Balancer public ne peut être créé. L'accès entrant à vos applications passe par vos propres équipements.
Note

Avec le plan Standard, defaultVrackGateway et privateNetworkRoutingAsDefault ne sont pas utilisés : la passerelle des nœuds est celle configurée sur le sous-réseau des nœuds.

Prérequis

Côté Kubernetes :

  • Disposer d'un projet Public Cloud dans votre compte OVHcloud.
  • Disposer d'un cluster du plan Standard créé depuis le 13 octobre 2026, avec les options décrites ci-dessous.

Côté réseau, quelle que soit votre appliance (appliance virtuelle sur des instances Public Cloud, serveur dédié ou équipement on-premises relié à votre vRack) :

  • Disposer d'un réseau privé (vRack) avec un sous-réseau pour les nœuds, dans la région du cluster.
  • Le sous-réseau annonce une passerelle par défaut (DHCP option 3), et cette adresse de passerelle est portée par votre appliance. Avec la console OVHcloud ou l'API OVHcloud, le sous-réseau annonce sa première adresse : cochez Annoncer la première adresse d'un CIDR donné comme passerelle par défaut (DHCP option 3), ou définissez noGateway à false. Avec l'API OpenStack, vous pouvez choisir une autre adresse.
  • Le DHCP est activé sur le sous-réseau (recommandé), et sa plage d'allocation n'inclut pas l'adresse de la passerelle.
  • Aucune passerelle managée OVHcloud sur ce sous-réseau.
  • Votre appliance route le trafic sortant des nœuds et autorise au minimum le DNS (port 53, TCP et UDP), ainsi que l'accès à Internet dont vos workloads ont besoin, par exemple pour récupérer des images depuis des registres de conteneurs publics.

Recommandations :

  • Rendez la passerelle hautement disponible, par exemple avec deux appliances qui partagent l'adresse de passerelle sous forme d'IP virtuelle (VRRP ou CARP) : une appliance unique est un point de défaillance unique pour l'accès externe de vos workloads.
  • Si votre appliance fonctionne sur des instances Public Cloud, l'adresse de passerelle doit être réservée par un port de votre appliance, et la sécurité de port doit être désactivée sur ses interfaces pour qu'elle puisse acheminer un trafic qui ne lui est pas destiné. Ces réglages sont disponibles via l'API OpenStack.
Tip

La conception du hub (choix de l'appliance, haute disponibilité, règles de filtrage et de routage) dépend de votre environnement. Pour mettre en place la partie réseau, suivez le guide « Landing zone hub and spoke sur OVHcloud Public Cloud ». L'appliance peut aussi se trouver dans un réseau hub distinct : la passerelle annoncée sur le sous-réseau des nœuds est alors un routeur OpenStack, qui achemine le trafic vers ce hub. Si vous avez besoin d'un accompagnement pour la concevoir ou la déployer, contactez votre commercial ou nos équipes Professional Services.

Options réseau du cluster

Côté Managed Kubernetes, deux attributs du cluster contrôlent cette configuration. Tous deux sont optionnels et valent false par défaut ; pour utiliser votre propre routeur, définissez-les tous deux à true.

AttributDescription
disablePublicNetworkingDésactive l'exposition publique des nœuds et des workloads : aucune Floating IP ne peut être attachée aux nœuds ni aux load balancers, donc aucun Load Balancer public ne peut être créé. L'API server Kubernetes n'est pas concerné. Utilisé seul, il exige toujours une passerelle managée OVHcloud dans le sous-réseau des nœuds pour l'accès sortant à Internet : il sert alors de garde-fou contre toute exposition publique, consultez le guide « Comprendre l'architecture d'OVHcloud Managed Kubernetes ».
privateNetworkConfiguration.useUserGatewayLes nœuds utilisent votre routeur, passerelle du sous-réseau des nœuds, comme passerelle par défaut. Exige disablePublicNetworking à true.
Warning

Ces attributs ne peuvent être définis qu'à la création du cluster et ne sont plus modifiables ensuite.

Lorsque disablePublicNetworking vaut true :

  • aucune Floating IP ne peut être attachée aux nœuds ni aux load balancers ;
  • les Services de type LoadBalancer ne peuvent pas être exposés via un Load Balancer public.

Si vous devez exposer des applications sur Internet depuis ce cluster, conservez la configuration par défaut.

Cette option ne concerne pas l'API server Kubernetes, qui reste accessible publiquement avec vos restrictions d'IP.

Si la configuration n'est pas valide, la création du cluster est refusée :

SituationMessage d'erreur
useUserGateway à true sans disablePublicNetworking à trueuseUserGateway require publicConnectivityDisabled
disablePublicNetworking à true seul, sans passerelle managée dans le sous-réseau des nœudsmissing a gateway in nodesSubnetId
Cluster du plan Freenot supported

Créer le cluster

Console OVHcloud
API OVHcloud
CLI OVHcloud
Terraform
Info

La prise en charge de ces options dans la console OVHcloud est en cours. En attendant, utilisez l'API OVHcloud ou Terraform.

Ajouter un pool de nœuds

Les Floating IP ne peuvent pas être attachées aux nœuds de ce cluster : ne les activez pas sur le pool de nœuds. Dans une région à plusieurs zones de disponibilité, comme EU-WEST-PAR, choisissez la zone du pool de nœuds.

Console OVHcloud
API OVHcloud
CLI OVHcloud
Terraform

Ajoutez un pool de nœuds depuis l'onglet Pools de nœuds de votre cluster en suivant le guide « Gérer les nœuds et les pools de nœuds d'un cluster OVHcloud Managed Kubernetes ».

Vérifier la configuration

Vérifiez la configuration du cluster avec l'appel API suivant :

La réponse contient "disablePublicNetworking": true et "privateNetworkConfiguration": { "useUserGateway": true }.

Une fois le pool de nœuds à l'état READY, récupérez le fichier kubeconfig de votre cluster (consultez la section « Connexion au cluster » du guide « Créer un cluster » ; avec Terraform, utilisez l'output kubeconfig) et lancez un Pod de test qui affiche son IP de sortie :

kubectl run egress-test --rm -it --restart=Never --image=curlimages/curl -- curl -s https://ifconfig.me

La commande doit renvoyer l'adresse IP publique que votre routeur ou pare-feu utilise pour le trafic sortant.

Note

Pour un cluster existant qui ne peut pas être recréé, nos équipes peuvent étudier au cas par cas une migration manuelle vers cette configuration. Contactez votre commercial.

Router la sortie via une passerelle dans votre vRack (plan Free)

Ce tutoriel s'applique aux clusters du plan Free.

Dans ce tutoriel, nous allons utiliser une passerelle personnalisée déployée dans le vRack avec un cluster Managed Kubernetes.

Pourquoi ?

Par défaut, dans un cluster Kubernetes, les pods que vous déployez utilisent l'IP de sortie du nœud. Nous avons donc autant d'IP de sortie que de nœuds. Cela peut poser problème lorsque vous devez gérer une liste d'autorisation et que votre cluster utilise l'autoscaling (création et suppression de nœuds à la volée).

Une solution consiste à utiliser une passerelle personnalisée, qui vous permet de disposer d'une seule IP de sortie (votre passerelle).

Vous allez :

  • créer un réseau privé
  • créer des sous-réseaux
  • créer un routeur OpenStack (dans chaque région) et le relier au réseau du fournisseur externe ainsi qu'aux sous-réseaux
  • créer un cluster OVHcloud Managed Kubernetes avec la passerelle privée
  • tester l'IP de sortie du pod

À la fin de ce tutoriel, vous devriez obtenir le flux suivant :

Schéma passerelle vRack

Info

Dans ce tutoriel, nous vous guidons pour créer le réseau privé dans deux régions, mais vous pouvez n'en utiliser qu'une seule si vous le souhaitez, par exemple GRA9.

Prérequis

Initialisation

Dans ce tutoriel, vous utilisez la CLI OVHcloud pour créer le réseau privé, les sous-réseaux et le cluster Kubernetes, et la CLI OpenStack pour créer les routeurs et les routes des sous-réseaux.

Configurez la CLI OVHcloud avec vos identifiants de l'API OVHcloud en suivant la documentation de la CLI OVHcloud.

Pour gérer OpenStack, créez un dossier utils dans votre environnement/machine locale, puis créez-y le fichier utils/openrc, ou téléchargez-le depuis votre fournisseur OpenStack. Il doit ressembler à ceci :

export OS_AUTH_URL=https://auth.cloud.ovh.net/v3
export OS_IDENTITY_API_VERSION=3
export OS_USER_DOMAIN_NAME=${OS_USER_DOMAIN_NAME:-"Default"}
export OS_PROJECT_DOMAIN_NAME=${OS_PROJECT_DOMAIN_NAME:-"Default"}
export OS_TENANT_ID=xxxxxxxxxxxxxxxxxxxxx
export OS_TENANT_NAME="xxxxxxxxxxxxxxxxxx"
export OS_USERNAME="user-xxxxxxxxxxxxx"
export OS_PASSWORD="xxxxxxxxxxxxxxxxxx"
export OS_REGION_NAME="xxxx"
if [ -z "$OS_REGION_NAME" ]; then unset OS_REGION_NAME; fi

Chargez les variables :

. utils/openrc

La variable OS_TENANT_ID contient l'ID de votre projet Public Cloud : les commandes de la CLI OVHcloud de ce tutoriel l'utilisent avec l'option --cloud-project.

Créer le réseau privé

Important : nous supposons que votre projet PCI est ajouté à votre vRack.

Pour ce tutoriel, nous utilisons les deux régions GRA9 et GRA11.

Créez le réseau privé nommé demo-pvnw, avec l'ID de VLAN 20, dans les régions GRA9 et GRA11 :

CLI OVHcloud
API

Avec la CLI OVHcloud, un réseau privé est créé dans une seule région : créez un réseau par région, avec le même ID de VLAN, et récupérez leurs ID (pvnwGRA9Id et pvnwGRA11Id).

export pvnwGRA9Id="$(ovhcloud cloud network private vrack create GRA9 --cloud-project $OS_TENANT_ID --name demo-pvnw --vlan-id 20 --wait -o details.id)" && echo $pvnwGRA9Id

export pvnwGRA11Id="$(ovhcloud cloud network private vrack create GRA11 --cloud-project $OS_TENANT_ID --name demo-pvnw --vlan-id 20 --wait -o details.id)" && echo $pvnwGRA11Id

Créer des sous-réseaux

Pour ce tutoriel, nous divisons un sous-réseau /24 pour obtenir deux sous-réseaux /25.

Réf. : https://www.davidc.net/sites/default/subnets/subnets.html

NomRégionAdresse CIDRPasserellePlage DHCPDiffusion
Sous-réseau 1GRA9192.168.0.0/25192.168.0.1192.168.0.2-192.168.0.126192.168.0.127
Sous-réseau 2GRA11192.168.0.128/25192.168.0.129192.168.0.130-192.168.0.254192.168.0.255

Créez les sous-réseaux, et récupérez leurs ID (subnGRA9 et subnGRA11) :

CLI OVHcloud
API
export subnGRA9="$(ovhcloud cloud network private vrack subnet create $pvnwGRA9Id --cloud-project $OS_TENANT_ID \
  --name demo-subnet-gra9 --cidr 192.168.0.0/25 --gateway-ip 192.168.0.1 \
  --allocation-pools 192.168.0.2:192.168.0.126 --wait -o details.id)" && echo $subnGRA9

export subnGRA11="$(ovhcloud cloud network private vrack subnet create $pvnwGRA11Id --cloud-project $OS_TENANT_ID \
  --name demo-subnet-gra11 --cidr 192.168.0.128/25 --gateway-ip 192.168.0.129 \
  --allocation-pools 192.168.0.130:192.168.0.254 --wait -o details.id)" && echo $subnGRA11

Il n'est pas possible d'ajouter des routes aux sous-réseaux avec la CLI OVHcloud, il faut donc utiliser la CLI OpenStack.

CLI OpenStack
openstack --os-region-name=GRA9 subnet set ${subnGRA9} --host-route destination=192.168.0.0/25,gateway=192.168.0.1

openstack --os-region-name=GRA11 subnet set ${subnGRA11} --host-route destination=192.168.0.128/25,gateway=192.168.0.129

Routeur OpenStack

Créer les routeurs

Nous avons la possibilité de créer des routeurs virtuels OpenStack. Pour cela, nous devons utiliser la CLI OpenStack. Créez les routeurs et récupérez leurs ID (rtrGRA9Id et rtrGRA11Id) :

CLI OpenStack
export rtrGRA9Id="$(openstack --os-region-name=GRA9 router create rtr-GRA9 -f json | jq -r .id)" && echo $rtrGRA9Id
export rtrGRA11Id="$(openstack --os-region-name=GRA11 router create rtr-GRA11 -f json | jq -r .id)" && echo $rtrGRA11Id

Vous devriez obtenir un résultat de ce type :

$ export rtrGRA9Id="$(openstack --os-region-name=GRA9 router create rtr-GRA9 -f json | jq -r .id)" && echo $rtrGRA9Id
26bf99c8-d6fa-4c5a-9d42-1358776ee0a2

$ export rtrGRA11Id="$(openstack --os-region-name=GRA11 router create rtr-GRA11 -f json | jq -r .id)" && echo $rtrGRA11Id
5c1e3f0a-8b2d-4e6f-9a7c-3d4b5e6f7a8b

Relier le routeur au réseau du fournisseur externe

Tout d'abord, récupérez l'ID du réseau externe régional (extNwGRA9Id et extNwGRA11Id), puis reliez-le au routeur :

CLI OpenStack
# GRA9
export extNwGRA9Id="$(openstack --os-region-name=GRA9 network list -f json | jq -r '.[] | select(.Name=="Ext-Net") | .ID')" && echo $extNwGRA9Id
openstack --os-region-name=GRA9 router set $rtrGRA9Id --external-gateway $extNwGRA9Id
# GRA11
export extNwGRA11Id="$(openstack --os-region-name=GRA11 network list -f json | jq -r '.[] | select(.Name=="Ext-Net") | .ID')" && echo $extNwGRA11Id
openstack --os-region-name=GRA11 router set $rtrGRA11Id --external-gateway $extNwGRA11Id

Vous devriez obtenir un résultat de ce type :

$ export extNwGRA9Id="$(openstack --os-region-name=GRA9 network list -f json | jq -r '.[] | select(.Name=="Ext-Net") | .ID')" && echo $extNwGRA9Id
b2c02fdc-ffdf-40f6-9722-533bd7058c06
$ openstack --os-region-name=GRA9 router set $rtrGRA9Id --external-gateway $extNwGRA9Id

$ export extNwGRA11Id="$(openstack --os-region-name=GRA11 network list -f json | jq -r '.[] | select(.Name=="Ext-Net") | .ID')" && echo $extNwGRA11Id
bcf59eb2-9d83-41cc-b4f5-0435ed594833
$ openstack --os-region-name=GRA11 router set $rtrGRA11Id --external-gateway $extNwGRA11Id

Vous pouvez maintenant afficher les informations de votre nouveau routeur virtuel sur GRA9 afin d'afficher son IP :

$ openstack --os-region-name=GRA9 router show $rtrGRA9Id -c id -c name -c status -c created_at -c external_gateway_info
+-----------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Field                 | Value                                                                                                                                                                                                                                                                                     |
+-----------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| created_at            | 2022-07-25T07:32:06Z                                                                                                                                                                                                                                                                      |
| external_gateway_info | {"network_id": "b2c02fdc-ffdf-40f6-9722-533bd7058c06", "external_fixed_ips": [{"subnet_id": "0f11270c-1113-4d4f-98de-eba83445d962", "ip_address": "141.94.209.244"}, {"subnet_id": "4aa6cac1-d5cd-4e25-b14b-7573aeabcab1", "ip_address": "2001:41d0:304:400::917"}], "enable_snat": true} |
| id                    | 26bf99c8-d6fa-4c5a-9d42-1358776ee0a2                                                                                                                                                                                                                                                      |
| name                  | rtr-GRA9                                                                                                                                                                                                                                                                                  |
| status                | ACTIVE                                                                                                                                                                                                                                                                                    |
+-----------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

Comme vous pouvez le voir, dans cet exemple, l'IP de la passerelle sera 141.94.209.244.

Relier le routeur au sous-réseau

Faites de même avec les sous-réseaux régionaux :

CLI OpenStack
# GRA9
openstack --os-region-name=GRA9 router add subnet $rtrGRA9Id $subnGRA9
# GRA11
openstack --os-region-name=GRA11 router add subnet $rtrGRA11Id $subnGRA11

Créer un cluster Kubernetes avec passerelle privée

Le réseau est maintenant prêt. Créez un cluster OVHcloud Managed Kubernetes en spécifiant l'utilisation de la passerelle définie sur chaque sous-réseau.

Remarque : jusqu'à la fin de ce tutoriel, nous n'utilisons que la région GRA9, mais vous pouvez répéter exactement les mêmes étapes pour créer un cluster dans la région GRA11.

Info

Dans ce guide, nous avons défini la version 1.34 pour le cluster Kubernetes, mais vous pouvez utiliser une autre version prise en charge.

Créez le cluster OVHcloud Managed Kubernetes dans GRA9, sur le réseau privé GRA9 (pvnwGRA9Id), et récupérez l'ID du cluster (kubeId) :

CLI OVHcloud
API
Console OVHcloud
Terraform

Créez un fichier data-kube.json avec les paramètres du cluster et de son pool de nœuds :

{
  "region": "GRA9",
  "name": "demo",
  "version": "1.34",
  "nodepool": {
    "flavorName": "b3-8",
    "antiAffinity": false,
    "monthlyBilled": false,
    "autoscale": false,
    "desiredNodes": 3
  },
  "privateNetworkConfiguration": {
    "privateNetworkRoutingAsDefault": true,
    "defaultVrackGateway": "192.168.0.1"
  }
}

Puis créez le cluster avec l'ID du réseau privé GRA9 :

export kubeId="$(ovhcloud cloud managed-kubernetes create --cloud-project $OS_TENANT_ID --from-file data-kube.json --private-network-id $pvnwGRA9Id -o details.id)" && echo $kubeId

Attendez maintenant que votre cluster OVHcloud Managed Kubernetes soit à l'état READY.

Pour cela, vous pouvez vérifier son statut dans la console OVHcloud :

Cliquez sur Managed Kubernetes Service sous Conteneurs dans le menu de gauche de votre projet Public Cloud.

Cliquez sur votre cluster demo : son onglet Réseau indique qu'il est attaché au réseau demo-pvnw.

Son statut est affiché dans l'onglet Vue d'ensemble.

Lorsque le statut de votre cluster est OK, vous pouvez passer à la section suivante.

Récupérer le fichier Kubeconfig

Pour continuer avec le cluster Kubernetes nouvellement créé, vous devez récupérer le fichier Kubeconfig.

CLI OVHcloud
API
Terraform
ovhcloud cloud managed-kubernetes kubeconfig generate $kubeId --cloud-project $OS_TENANT_ID > kubeconfig-demo.yml

Pour utiliser ce fichier kubeconfig et accéder à votre cluster, vous pouvez suivre notre tutoriel configurer kubectl, ou simplement ajouter l'option --kubeconfig dans vos commandes kubectl.

Test

Listez les nœuds actifs de votre cluster :

kubectl --kubeconfig=kubeconfig-demo.yml get no -o wide

Vous devriez obtenir un résultat de ce type :

$ kubectl --kubeconfig=kubeconfig-demo.yml get no -o wide
NAME                                         STATUS   ROLES    AGE   VERSION   INTERNAL-IP    EXTERNAL-IP      OS-IMAGE             KERNEL-VERSION       CONTAINER-RUNTIME
nodepool-8f0b4d98-874a-4cfd-b8-node-c74f26   Ready    <none>   56m   v1.34.0   192.168.0.71   141.94.215.23    Ubuntu 18.04.6 LTS   4.15.0-189-generic   containerd://1.4.6
nodepool-8f0b4d98-874a-4cfd-b8-node-c9bf60   Ready    <none>   57m   v1.34.0   192.168.0.96   141.94.208.78    Ubuntu 18.04.6 LTS   4.15.0-189-generic   containerd://1.4.6
nodepool-8f0b4d98-874a-4cfd-b8-node-e666f5   Ready    <none>   56m   v1.34.0   192.168.0.31   141.94.212.214   Ubuntu 18.04.6 LTS   4.15.0-189-generic   containerd://1.4.6

Testez maintenant le cluster en exécutant un conteneur simple qui demande son adresse IP publiée.

kubectl --kubeconfig=kubeconfig-demo.yml run --image=debian debian -it -- bash
apt update
apt install -y curl
curl ifconfig.me

Vous devriez obtenir un résultat de ce type :

$ kubectl --kubeconfig=kubeconfig-demo.yml run --image=debian debian  -it -- bash
If you don't see a command prompt, try pressing enter.
root@debian:/# apt update
Get:1 http://deb.debian.org/debian bullseye InRelease [116 kB]
Get:2 http://deb.debian.org/debian-security bullseye-security InRelease [48.4 kB]
Get:3 http://deb.debian.org/debian bullseye-updates InRelease [44.1 kB]
Get:4 http://deb.debian.org/debian bullseye/main amd64 Packages [8182 kB]
Get:5 http://deb.debian.org/debian-security bullseye-security/main amd64 Packages [167 kB]
Get:6 http://deb.debian.org/debian bullseye-updates/main amd64 Packages [2592 B]
...

root@debian:/# apt install -y curl
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
The following additional packages will be installed:
  ca-certificates libbrotli1 libcurl4 libldap-2.4-2 libldap-common libnghttp2-14 libpsl5 librtmp1 libsasl2-2 libsasl2-modules libsasl2-modules-db libssh2-1 openssl publicsuffix
Suggested packages:
...

root@debian:/# curl ifconfig.me
141.94.209.244

L'adresse IP de notre pod est bien celle de notre passerelle !

Suppression (nettoyage)

Pour supprimer les ressources créées, suivez les instructions ci-dessous :

Cluster Kubernetes

CLI OVHcloud
API
Terraform
ovhcloud cloud managed-kubernetes delete $kubeId --cloud-project $OS_TENANT_ID

Routeurs

Pour supprimer un routeur OpenStack, vous devez d'abord retirer les ports qui lui sont liés.

CLI OpenStack
# Get the routers subnets attached ports Ids
export portIdGRA9="$(openstack --os-region-name=GRA9 port list | grep -w "192.168.0.1" | awk '{print $2}')" && echo $portIdGRA9
export portIdGRA11="$(openstack --os-region-name=GRA11 port list | grep -w "192.168.0.129" | awk '{print $2}')" && echo $portIdGRA11
# Get the routers Ids
export rtrIdGRA9="$(openstack --os-region-name=GRA9 router list -f json | jq -r '.[] | select(.Name=="rtr-GRA9") | .ID')" && echo $rtrIdGRA9
export rtrIdGRA11="$(openstack --os-region-name=GRA11 router list -f json | jq -r '.[] | select(.Name=="rtr-GRA11") | .ID')" && echo $rtrIdGRA11
# Remove ports from routers
openstack --os-region-name=GRA9 router remove port $rtrIdGRA9 $portIdGRA9
openstack --os-region-name=GRA11 router remove port $rtrIdGRA11 $portIdGRA11
# Delete routers
openstack --os-region-name=GRA9 router delete $rtrIdGRA9
openstack --os-region-name=GRA11 router delete $rtrIdGRA11

Sous-réseaux

CLI OVHcloud
API
ovhcloud cloud network private vrack subnet delete $pvnwGRA9Id $subnGRA9 --cloud-project $OS_TENANT_ID
ovhcloud cloud network private vrack subnet delete $pvnwGRA11Id $subnGRA11 --cloud-project $OS_TENANT_ID

Réseau privé

CLI OVHcloud
API
ovhcloud cloud network private vrack delete $pvnwGRA9Id --cloud-project $OS_TENANT_ID
ovhcloud cloud network private vrack delete $pvnwGRA11Id --cloud-project $OS_TENANT_ID

Aller plus loin

Échangez avec notre communauté d'utilisateurs.

Cette page vous a-t-elle aidé ?