Tutoriel : Configurer un Net peering avec OKS CLI (bêta)

Cette fonctionnalité est actuellement en bêta. Pour en savoir plus sur les services bêta, voir le Glossaire et nos Conditions générales de ventes et d’utilisation.

Dans ce tutoriel, vous apprendrez comment configurer un Net peering (appairage de réseaux), soit entre l’un de vos Nets et un de vos projets, soit entre deux de vos projets.

Vous pouvez appairer un projet à un Net afin de sécuriser la communication entre vos clusters et des ressources externes qui se trouvent dans différents comptes et Nets.

Lorsque vous créez un projet, OKS y créé automatiquement un Net. Le Net peering se fait toujours entre les Nets et non entre les projets eux-même. Cela signifie que lors d’un peering entre un Net et un projet OKS, ou entre deux projets, vous appairez en réalité leurs Nets sous-jacents. Afin d’être plus compréhensible, ce tutoriel utilises "projet" pour désigner le Net du projet.

Bien que le peering en lui-même soit établi au niveau du Net, la requête de peering doit en fait être initiée ou acceptée depuis un cluster à l’intérieur du projet à l’aide de custom resources (ressources ur mesure). Une fois le projet appairé, tous les clusters de celui-ci accèdent automatiquement au Net.

Vous pouvez soit configurer le Net peering :

  • Depuis le cluster vers le Net, avec une requête de peering comme custom resource.

  • Depuis le Net vers le cluster, avec une acceptation de peering comme custom resource.

  • Depuis le cluster d’un projet vers le cluster d’un autre projet, avec une requête de peering et une acceptation de peering commme custom resources.

Il est impossible de créer un Net peering entre un cluster et un Net ayant des blocs CIDR qui se chevauchent. Le bloc CIDR utilisé lors de la création du Net doit être différent de celui du projet contenant le cluster à partir duquel vous initiez le peering. Il en va de même lors d’un peering entre deux projets. Pour en savoir plus, voir Obtenir des informations sur vos Net peerings.

Il est possible d’appairer votre cluster à un Net d’un compte différent, la logique de ce tutoriel reste la même.

Configurer un Net peering de votre cluster vers votre Net

Avant de commencer :

  1. Créez la custom resource pour la requête de peering. Cette ressource est un fichier YAML dans lequel vous devez ajouter les informations suivantes :

    • accepterNetId : l’ID du Net que vous avez créé.

    • accepterOwnerId : l’ID de votre compte OUTSCALE.

      peering-request.yaml
      apiVersion: oks.dev/v1beta
kind: NetPeeringRequest
metadata:
  name: peering-request
spec:
  accepterNetId: ID_OF_YOUR_NET
  accepterOwnerId: "ID_YOUR_OUTSCALE_ACCOUNT"

  2. Appliquez le fichier de requête de peering à votre cluster en utilisant la commande suivante :

    Exemple de requête
    $ oks-cli cluster --project-name "NAME_OF_PROJECT" --cluster-name NAME_OF_CLUSTER kubectl apply -f ~/PATH/peering-request.yaml
    Exemple de résultat
    netpeeringrequest.oks.dev/peering-request created

  3. Lancez la commande suivante afin d’obtenir l’ID du Net peering qui est nécessaire afin d’en accepter la requête :

    Exemple de requête
    $ oks-cli cluster --project-name "NAME_OF_PROJECT" --cluster-name NAME_OF_CLUSTER kubectl get npr
    Exemple de résultat
    NAME              SOURCE NET ID   ACCEPTER NET ID   NET PEERING ID   STATE NAME           STATE MESSAGE                        EXPIRATION DATE
peering-request   ID_OF_YOUR_CLUSTER    ID_OF_YOUR_NET     ID_OF_NET_PEERING     pending-acceptance   Pending acceptance by ID_YOUR_OUTSCALE_ACCOUNT

  4. Acceptez la requête de peering du côté du Net avec OSC CLI :

    Exemple de requête
    $ osc-cli api AcceptNetPeering --NetPeeringId "ID_OF_NET_PEERING"

  5. Vous pouvez vérifier que le peering a bien été configuré avec la commande suivante :

    Exemple de requête
    $ oks-cli cluster --project-name "project-1" --cluster-name cluster-1 kubectl get npeer
    Exemple de résultat
    NAME           SOURCE NET ID   ACCEPTER NET ID   NET PEERING ID   STATE NAME   STATE MESSAGE   EXPIRATION DATE
pcx-1a2b3c4d   ID_OF_YOUR_CLUSTER    ID_OF_YOUR_NET     ID_OF_NET_PEERING     active       Active          2025-08-04T11:28:46.000Z

    Vous pouvez également vérifier que le peering a bien été configuré avec Cockpit et OSC CLI. Pour en savoir plus, voir Obtenir des informations sur vos Net peerings.

Un Net peering n’expire jamais. Vous pouvez ignorer la date d’expiration qui apparaît dans le résultat de la commande OKS CLI.

Gérer le trafic

Une fois le peering mis en place, le trafic doit être dirigé et autorisé entre les deux côtés de la connexion :

Si tous les comptes appairés ont accès à OKS, aucune action supplémentaire n’est nécessaire. OKS gérera automatiquement le trafic.

Si un des comptes appairés n’a pas accès à OKS, l’utilisateur de ce compte doit configurer le routage manuellement :

  1. Créez une route afin que le trafic puisse atteindre le projet appairé.

    La route doit :

    • Utiliser le bloc CIDR du projet appairé comme destination.

    • Utiliser l’ID du Net appairé comme cible.

    Pour en savoir plus, voir Tutoriel : Configurer un Net peering et Créer une route.

  2. Configurez des règles de security groups pour les VM dans votre Net.

    Ajoutez une règle ou plus autorisant le trafic à passer entre les deux côtés du peering :

    • Pour le flux entrant : autorisez le trafic venant d’au moins un security group du Net appairé.

    • Pour le flux sortant : autorisez le trafic vers au moins un security group du Net appairé.

    Pour en savoir plus, voir Ajouter des règles à un security group.

Configurer un Net peering de votre Net vers votre cluster

Avant de commencer :

  • Créez un Net. Cette action peut être réalisée avec Cockpit ou OSC CLI. Pour en savoir plus, voir Créer un Net.

  • Créez un cluster à appairer à votre Net. Pour en savoir plus, voir Créer un Net.

  • Créez un node pool et obtenez des informations à propos de ce node pool. Pour en savoir plus, voir Lister vos node pools > Lister vos node pools avec kubectl. Cela vous permet de réunir les informations suivantes à propos du cluster que vous avez créez :

    • l’ID de votre compte OKS (oks.account-id),

    • l’ID de votre réseau OKS (oks.network_id).

  1. Créez un Net peering avec l’ID du Net (SourceNetId) que vous avez créé précédemment, l’ID do votre réseau OKS (AccepterNetId), qui représente l’ID de votre cluster, et l’ID de votre compte OKS (AccepterOwnerId). Pour en savoir plus, voir Créer un Net peering.

    Exemple de requête
    $ osc-cli api CreateNetPeering --profile exp-dev-010 --SourceNetId "ID_OF_YOUR_NET" --AccepterNetId "ID_OF_YOUR_CLUSTER" --AccepterOwnerId '"ID_OF_OKS_ACCOUNT"'
    Exemple de résultat
    {
    "ResponseContext": {
        "RequestId": "b99e373a-4abe-4249-bd37-08dbfe9caa1c"
    },
    "NetPeering": {
        "Tags": [],
        "State": {
            "Name": "pending-acceptance",
            "Message": "Pending acceptance by ID_OF_OKS_ACCOUNT"
        },
        "AccepterNet": {
            "NetId": "ID_OF_YOUR_CLUSTER",
            "IpRange": "10.50.0.0/16",
            "AccountId": "ID_OF_OKS_ACCOUNT"
        },
        "SourceNet": {
            "NetId": "ID_OF_YOUR_NET",
            "IpRange": "192.168.0.0/16",
            "AccountId": "ID_YOUR_OUTSCALE_ACCOUNT"
        },
        "NetPeeringId": "ID_OF_NET_PEERING"
    }
}

  2. Créez la custom resource pour l’acceptation de peering. Cette ressource est un fichier YAML dans lequel vous devez ajouter l’ID du Net peering obtenue précédemment :

    peering-acceptance.yaml
    apiVersion: oks.dev/v1beta
kind: NetPeeringAcceptance
metadata:
  name: peering-acceptance
spec:
  netPeeringId: ID_OF_NET_PEERING

  3. Appliquez le fichier d’acceptation de peering à votre cluster :

    Exemple de requête
    $ oks-cli cluster --project-name "project-1" --cluster-name cluster-1 kubectl apply -f ~/PATH/peering-acceptance.yaml
    Exemple de résultat
    netpeeringacceptance.oks.dev/peering-acceptance created

  4. Vous pouvez vérifier que le peering a bien été congfiguré avec la commande suivante :

    Exemple de requête
    $ oks-cli cluster --project-name "projet1" --cluster-name cluster1 kubectl get npeer
    Exemple de résultat
    NAME           SOURCE NET ID   ACCEPTER NET ID   NET PEERING ID   STATE NAME   STATE MESSAGE   EXPIRATION DATE
pcx-1a2b3c4d   ID_OF_YOUR_NET    ID_OF_YOUR_CLUSTER     ID_OF_NET_PEERING     active       Active          2025-08-04T11:28:46.000Z

    Vous pouvez également vérifier que le peering a bien été configuré avec Cockpit et OSC CLI. Pour en savoir plus, voir Obtenir des informations sur vos Net peerings.

Un Net peering n’expire jamais. Vous pouvez ignorer la date d’expiration qui apparaît dans le résultat de la commande OKS CLI.

Gérer le trafic

Une fois le peering mis en place, le trafic doit être dirigé et autorisé entre les deux côtés de la connexion :

Si tous les comptes appairés ont accès à OKS, aucune action supplémentaire n’est nécessaire. OKS gérera automatiquement le trafic.

Si un des comptes appairés n’a pas accès à OKS, l’utilisateur de ce compte doit configurer le routage manuellement :

  1. Créez une route pour afin que le trafic puisse atteindre le projet appairé.

    La route doit :

    • Utiliser le bloc CIDR du projet appairé comme destination.

    • Utiliser l’ID du Net appairé comme cible.

    Pour en savoir plus, voir Tutoriel : Configurer un Net peering et Créer une route.

  2. Configurez des règles de security groups pour les VM dans votre Net.

    Ajoutez une règle ou plus autorisant le trafic à passer entre les deux côtés du peering :

    • Pour le flux entrant : autorisez le trafic venant d’au moins un security group du Net appairé.

    • Pour le flux sortant : autorisez le trafic vers au moins un security group du Net appairé.

    Pour en savoir plus, voir Ajouter des règles à un security group.

Configurer un Net peering d’un cluster à un autre

Créer le Net peering

Avant de commencer :

  • Créez deux projets avec des blocs CIDR différents. Pour en savoir plus, voir Créer un projet.

  • Créez deux clusters à appairer, un dans chacun des projets créés précédemment. Pour en savoir plus, voir Créer un cluster. Pour plus de clarté, ces clusters seront appelés « cluster source » et « cluster cible » dans ce tutoriel (ou « source cluster » et « target cluster » dans les exemples, respectivement).

  • Créez un node pool dans le cluster cible. Pour en savoir plus, voir Créer un node pool.

  1. Réunissez les informations suivantes :

    • L’ID du projet cible (oks.network_id). Pour ce faire, récupérez informations à propos du node pool créé dans le cluster cible. Pour plus de simplicité, vous pouvez sélectionner l’information requise en utilisant la commande egrep  :

      Exemple de requête
      $ oks-cli cluster --project-name "target-project" --cluster-name target-cluster kubectl describe nodepool target-nodepool | egrep "oks.network_id"
      Exemple de résultat
      oks.network_id=NET_ID_OF_TARGET_PROJECT

    • L’ID du compte qui a créé le projet cible, ici votre compte. Cet ID peut être obtenu avec la commande suivante :

      Exemple de requête
      $ oks-cli project quotas
      Exemple de résultat
      {
    "quotas": [
        {
            ...
            "AccountId": "ID_OF_YOUR_ACCOUNT",
            ...
        }
    ]
...
}

  2. Créez le fichier YAML de la custom resource pour la requête de peering, en le complétant avec les informations suivantes :

    • accepterNetId : l’ID du projet cible.

    • accepterOwnerId : l’ID de votre compte.

    peering-request.yaml
    apiVersion: oks.dev/v1beta
kind: NetPeeringRequest
metadata:
  name: peering-request
spec:
  accepterNetId: NET_ID_OF_TARGET_PROJECT
  accepterOwnerId: "ID_OF_YOUR_ACCOUNT"

  3. Appliquez la requête de peering au cluster source :

    Exemple de requête
    $ oks-cli cluster --project-name "source-project" --cluster-name source-cluster kubectl apply -f ~/PATH/peering-request.yaml
    Exemple de résultat
    netpeeringrequest.oks.dev/peering-request created

  4. Lancez la commande suivante pour obtenr l’ID du Net peering nécessaire pour accepter la requête de peering :

    Exemple de requête
    $ oks-cli cluster --project-name "source-project" --cluster-name source-cluster kubectl get npr
    Exemple de résultat
    NAME              SOURCE NET ID   ACCEPTER NET ID   NET PEERING ID   STATE NAME           STATE MESSAGE                        EXPIRATION DATE
peering-request   NET_ID_OF_SOURCE_PROJECT    NET_ID_OF_TARGET_PROJECT    ID_OF_NET_PEERING     pending-acceptance   Pending acceptance by ID_YOUR_ACCOUNT

  5. Créez le fichier YAML de la custom resource pour l’acceptation de peering, en le complétant avec l’ID du Net peering :

    peering-acceptance.yaml
    apiVersion: oks.dev/v1beta
kind: NetPeeringAcceptance
metadata:
  name: peering-acceptance
spec:
  netPeeringId: ID_OF_NET_PEERING

  6. Appliquez le fichier d’acceptation de peering au cluster cible :

    Exemple de requête
    $ oks-cli cluster --project-name "target-project" --cluster-name target-cluster kubectl apply -f ~/PATH/peering-acceptance.yaml
    Exemple de résultat
    netpeeringacceptance.oks.dev/peering-acceptance created

  7. Vous pouvez vérifier que le peering a bien été configuré avec la commande suivante :

    Exemple de requête
    $ oks-cli cluster --project-name "target-project" --cluster-name target-cluster kubectl get npeer
    Exemple de résultat
    NAME           SOURCE NET ID   ACCEPTER NET ID   NET PEERING ID   STATE NAME   STATE MESSAGE   EXPIRATION DATE
ID_OF_NET_PEERING   NET_ID_OF_SourCE_PROJECT   NET_ID_OF_TARGET_PROJECT   ID_OF_NET_PEERING     active       Active          2025-08-04T11:28:46.000Z

    Un Net peering n’expire jamais. Vous pouvez ignorer la date d’expiration qui apparaît dans le résultat de la commande OKS CLI.

Le routage est géré automatiquement par OKS. Vous n’avez donc pas besoin de créer de routes une fois que le Net peering est configuré.

Tester la connectivité

Pour accéder aux applications qui tournent dans OKS, vous devez les exposer avec un service (soit un NodePort ou un load balancer). Ces applications utiliseront ensuite le Net peering nouvellement créé. Les étapes suivantes vous montrent comment créér un service load balancer pour tester la connectivité de votre Net peering :

Avant de commencer :

Assurez-vous de remplir les prérequis suivants :

  • Au moins un node pool dans chaque cluster. Pour en savoir plus, voir Créer un node pool.

  • Des charges de travail source et cible de chaque côté.

  1. Créez le déploiement suivant et appliquez le fichier au cluster cible :

    ecoheaders-deployment.yaml
    apiVersion: apps/v1
kind: Deployment
metadata:
  name: echoheaders
  namespace: default
  labels:
    app: echoheaders
spec:
  replicas: 1
  selector:
    matchLabels:
      app: echoheaders
  template:
    metadata:
      labels:
        app: echoheaders
    spec:
      containers:
      - name: echoheaders
        image: gcr.io/google_containers/echoserver:1.10
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 8080
          protocol: TCP
    Exemple de requête
    $ oks-cli cluster --project-name "target-project" --cluster-name target-cluster kubectl apply -f ~/PATH/ecoheaders-deployment.yaml

  2. Créez un service de type LoadBalancer avec un load balancer interne et appliquez-le au cluster cible :

    ecoheaders-loadbalancer.yaml
    apiVersion: v1
kind: Service
metadata:
  name: echoheaders-lb-internal
  namespace: default
  labels:
    app: echoheaders
  annotations:
    service.beta.kubernetes.io/osc-load-balancer-name: "internal-lb-test"
    service.beta.kubernetes.io/osc-load-balancer-scheme: "internal"
spec:
  ports:
  - port: 80
    name: http
    protocol: TCP
    targetPort: 8080
  selector:
    app: echoheaders
  type: LoadBalancer
    Exemple de requête
    $ oks-cli cluster --project-name "target-project" --cluster-name target-cluster kubectl apply -f ~/PATH/ecoheaders-loadbalancer.yaml

  3. Récupérez le nom de DNS du load balancer :

    Exemple de requête
    $ oks-cli cluster --project-name "target-project" --cluster-name target-cluster kubectl get svc
    Exemple de résultat
    NAME                                   TYPE           CLUSTER-IP      EXTERNAL-IP                                            PORT(S)        AGE
echoheaders-lb-internal                LoadBalancer   10.92.72.99     internal-internal-lb-test.eu-west-2.lbu.outscale.com   80:31002/TCP   8s

  4. Vérifiez la connectivité avec cURL :

    Exemple de requête
    $ host internal-internal-lb-test.eu-west-2.lbu.outscale.com
    Exemple de résultat
    internal-internal-lb-test.eu-west-2.lbu.outscale.com has address 10.50.51.22

  5. À partir du cluster source, lancez la commande suivante (avec le nom de DNS adéquat) afin de tester le service et confirmer que les clusters peuvent communiquer convenablement :

    Exemple de requête
    $ oks-cli cluster --project-name "source-project" --cluster-name source-cluster kubectl run curl-pod --image=curlimages/curl --restart=Never --rm -it -- curl http://internal-internal-lb-test.eu-west-2.lbu.outscale.com
    Exemple de résultat
    Hostname: echoheaders-b6b6b99c8-kfv5h

Pod Information:
	-no pod information available-

Server values:
	server_version=nginx: 1.13.3 - lua: 10008

Request Information:
	client_address=10.91.3.142
	method=GET
	real path=/
	query=
	request_version=1.1
	request_scheme=http
	request_uri=http://internal-internal-lb-test.eu-west-2.lbu.outscale.com:8080/

Request Headers:
	accept=*/*
	host=internal-internal-lb-test.eu-west-2.lbu.outscale.com
	user-agent=curl/8.16.0

Request Body:
	-no body in request-

pod "curl-pod" deleted

Supprimer le Net peering

Vous pouvez supprimer le Net peering établi entre votre cluster et votre Net avec la commande kubectl delete npeer, suivie de l’ID de votre Net peering :

Exemple de requête
oks-cli cluster --project-name "projet1" --cluster-name cluster1 kubectl delete npeer ID_OF_NET_PEERING
Exemple de résultat
netpeering.oks.dev "ID_OF_NET_PEERING" deleted

Pages connexes

Exporter en PDF