Créer un cluster

Voir en Markdown

Découvrez comment créer un cluster Kubernetes managé par OVHcloud via l'espace client, l'API, la CLI, Terraform, Pulumi ou CDK pour Terraform

Objectif

Le service OVHcloud Managed Kubernetes vous permet de déployer des clusters prêts pour la production sans vous soucier de leur installation ou de leur maintenance. Créez un cluster via l'espace client OVHcloud, l'API, la CLI, ou automatisez le processus grâce à des outils d'Infrastructure as Code comme Terraform, Pulumi ou CDK pour Terraform.

Prérequis

Un projet Public Cloud dans votre compte OVHcloud

Tip

Bénéficiez de tarifs réduits en vous engageant sur une durée de 1 à 36 mois sur vos ressources Public Cloud. Plus d'informations sur notre page Savings Plans.

Accès à l'espace client OVHcloud

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

Info

L'API OVHcloud, la CLI, Terraform, CDK pour Terraform et Pulumi nécessitent des identifiants API OVHcloud (application_key, application_secret, consumer_key). Suivez le guide Premiers pas avec les API OVHcloud pour les générer.

En pratique

Via l'espace client OVHcloud

Via l'API OVHcloud

Via la CLI OVHcloud

Via Terraform

Via CDK pour Terraform

Via Pulumi

Cliquez sur Managed Kubernetes Service dans le menu de gauche, puis sur Créer un cluster.

Sélectionnez une localisation pour votre nouveau cluster.

Choisissez la version mineure de Kubernetes.

Info

Nous recommandons d'utiliser toujours la dernière version stable. Consultez notre page Fin de vie / fin de support pour comprendre notre politique de versions.

Vous pouvez intégrer votre cluster Kubernetes à un réseau privé via le vRack OVHcloud. Sélectionnez un réseau vRack existant dans la liste déroulante, ou ignorez cette étape pour configurer le réseau privé ultérieurement. Pour plus d'informations, consultez notre guide Utiliser le vRack.

Configurez le pool de nœuds par défaut. Un pool de nœuds est un groupe de nœuds partageant la même configuration. Vous pouvez ajouter un pool de nœuds dès maintenant ou ignorer cette étape pour en ajouter un plus tard. Consultez le guide Gérer les pools de nœuds pour plus d'informations.

Définissez la taille du pool de nœuds par défaut : saisissez un nom pour le pool, choisissez une flavor d'instance (type d'instance) et indiquez le nombre de nœuds.

Activez optionnellement l'Autoscaling et définissez la taille minimale et maximale du pool.

Choisissez le mode de facturation (mensuel ou horaire) et activez optionnellement le mode anti-affinité.

Info

L'anti-affinité répartit les nœuds sur différents hyperviseurs pour une meilleure tolérance aux pannes. Les pools de nœuds en anti-affinité sont limités à 5 nœuds. La facturation mensuelle ne peut pas être convertie en facturation horaire par la suite.

Saisissez un nom pour votre cluster, vérifiez le récapitulatif et cliquez sur Envoyer.

Le cluster sera disponible dans quelques minutes.

Warning

Une fois un cluster créé, la région et l'identifiant du réseau privé ne peuvent plus être modifiés.

Rendez-vous sur l'.

Créer le cluster :

Appelez l'endpoint suivant avec ce corps :

POST/cloud/project/{serviceName}/kube

{
  "name": "my-cluster",
  "region": "GRA7",
  "version": "1.34"
}

Info

Nous recommandons d'utiliser toujours la dernière version stable. Consultez notre page Fin de vie / fin de support pour comprendre notre politique de versions.

Notez l'id retourné dans la réponse — il sera nécessaire pour créer le pool de nœuds.

Créer un pool de nœuds :

Appelez l'endpoint suivant avec ce corps :

POST/cloud/project/{serviceName}/kube/{kubeId}/nodepool

{
  "name": "my-pool",
  "flavorName": "b2-7",
  "desiredNodes": 3,
  "minNodes": 3,
  "maxNodes": 3
}

Warning

Les noms de pool de nœuds n'acceptent que les caractères minuscules, les chiffres et le tiret -. Les underscores et les points ne sont pas pris en charge.

Warning

Une fois un cluster créé, la région et l'identifiant du réseau privé ne peuvent plus être modifiés.

Info

Installez la CLI OVHcloud et configurez vos identifiants avant de commencer.

Créer le cluster :

ovhcloud cloud kube create \
  --cloud-project <serviceName> \
  --name my-cluster \
  --region GRA7 \
  --version 1.34

Info

Nous recommandons d'utiliser toujours la dernière version stable. Consultez notre page Fin de vie / fin de support pour comprendre notre politique de versions.

Notez l'id dans la sortie — il sera nécessaire pour créer le pool de nœuds.

Créer un pool de nœuds :

ovhcloud cloud kube nodepool create <kubeId> \
  --cloud-project <serviceName> \
  --name my-pool \
  --flavor-name b2-7 \
  --desired-nodes 3 \
  --min-nodes 3 \
  --max-nodes 3

Warning

Les noms de pool de nœuds n'acceptent que les caractères minuscules, les chiffres et le tiret -. Les underscores et les points ne sont pas pris en charge.

Warning

Une fois un cluster créé, la région et l'identifiant du réseau privé ne peuvent plus être modifiés.

Info

Installez Terraform CLI (version 0.12.x minimum) avant de commencer.

OVHcloud fournit un provider Terraform disponible dans le registre officiel Terraform.

L'identifiant de votre projet Public Cloud correspond au service_name. Récupérez-le via le bouton Copier dans le presse-papier dans la section Public Cloud.

provider.tf :

terraform {
  required_providers {
    ovh = {
      source = "ovh/ovh"
    }
  }
}

provider "ovh" {
  endpoint           = "ovh-eu"
  application_key    = "<your_access_key>"
  application_secret = "<your_application_secret>"
  consumer_key       = "<your_consumer_key>"
}

Utilisez des variables d'environnement pour éviter de stocker des secrets dans votre code source : OVH_ENDPOINT, OVH_APPLICATION_KEY, OVH_APPLICATION_SECRET, OVH_CONSUMER_KEY.

variables.tf :

variable service_name {
  type    = string
  default = "<your_service_name>"
}

ovh_kube_cluster.tf :

resource "ovh_cloud_project_kube" "my_kube_cluster" {
   service_name = "${var.service_name}"
   name         = "my_kube_cluster"
   region       = "GRA7"
   version      = "1.34"
}

resource "ovh_cloud_project_kube_nodepool" "node_pool" {
   service_name  = "${var.service_name}"
   kube_id       = ovh_cloud_project_kube.my_kube_cluster.id
   name          = "my-pool"
   flavor_name   = "b2-7"
   desired_nodes = 3
   max_nodes     = 3
   min_nodes     = 3
}

output.tf :

output "kubeconfig" {
  value     = ovh_cloud_project_kube.my_kube_cluster.kubeconfig
  sensitive = true
}

Warning

Les noms de pool de nœuds n'acceptent que les caractères minuscules, les chiffres et le tiret -. Les underscores et les points génèrent une erreur gzip: invalid header.

Déployez :

terraform init && terraform apply

Info

Vous avez besoin de kubectl, de la CLI CDK pour Terraform et de Go installés.

CDKTF traduit le code Go en HCL Terraform et utilise le provider Terraform OVHcloud. Définissez les identifiants nécessaires sous forme de variables d'environnement :

export OVH_ENDPOINT="ovh-eu"
export OVH_APPLICATION_KEY="xxx"
export OVH_APPLICATION_SECRET="xxx"
export OVH_CONSUMER_KEY="xxx"
export OVH_CLOUD_PROJECT_SERVICE="xxx"

Initialisez le projet :

mkdir ovhcloud-kube && cd ovhcloud-kube
cdktf init --template=go --providers="ovh/ovh@~>0.37.0" "hashicorp/local" --providers-force-local --local --project-name=ovhcloud-kube

Éditez main.go :

package main

import (
    "os"
    "path"

    "cdk.tf/go/stack/generated/hashicorp/local/file"
    local "cdk.tf/go/stack/generated/hashicorp/local/provider"
    "cdk.tf/go/stack/generated/ovh/ovh/cloudprojectkube"
    "cdk.tf/go/stack/generated/ovh/ovh/cloudprojectkubenodepool"
    ovh "cdk.tf/go/stack/generated/ovh/ovh/provider"
    "github.com/aws/constructs-go/constructs/v10"
    "github.com/aws/jsii-runtime-go"
    "github.com/hashicorp/terraform-cdk-go/cdktf"
)

func NewMyStack(scope constructs.Construct, id string) cdktf.TerraformStack {
    stack := cdktf.NewTerraformStack(scope, &id)

    ovh.NewOvhProvider(stack, jsii.String("ovh"), &ovh.OvhProviderConfig{
        Endpoint: jsii.String("ovh-eu"),
    })
    local.NewLocalProvider(stack, jsii.String("local"), &local.LocalProviderConfig{})

    serviceName := os.Getenv("OVH_CLOUD_PROJECT_SERVICE")

    kube := cloudprojectkube.NewCloudProjectKube(stack, jsii.String("my_desired_cluster"), &cloudprojectkube.CloudProjectKubeConfig{
        ServiceName: jsii.String(serviceName),
        Name:        jsii.String("my_desired_cluster"),
        Region:      jsii.String("GRA5"),
    })

    cdktf.NewTerraformOutput(stack, jsii.String("cluster_version"), &cdktf.TerraformOutputConfig{
        Value: kube.Version(),
    })

    pwd, _ := os.Getwd()
    file.NewFile(stack, jsii.String("kubeconfig"), &file.FileConfig{
        Filename:       jsii.String(path.Join(pwd, "kubeconfig.yaml")),
        Content:        kube.Kubeconfig(),
        FilePermission: jsii.String("0644"),
    })

    nodePool := cloudprojectkubenodepool.NewCloudProjectKubeNodepool(stack, jsii.String("my-pool"), &cloudprojectkubenodepool.CloudProjectKubeNodepoolConfig{
        ServiceName:  kube.ServiceName(),
        KubeId:       kube.Id(),
        Name:         jsii.String("my-pool"),
        DesiredNodes: jsii.Number(1),
        MaxNodes:     jsii.Number(3),
        MinNodes:     jsii.Number(1),
        FlavorName:   jsii.String("b2-7"),
    })

    cdktf.NewTerraformOutput(stack, jsii.String("nodePoolID"), &cdktf.TerraformOutputConfig{
        Value: nodePool.Id(),
    })

    return stack
}

func main() {
    app := cdktf.NewApp(nil)
    NewMyStack(app, "ovhcloud")
    app.Synth()
}

Déployez :

cdktf deploy

Info

Vous avez besoin de la CLI Pulumi, d'un compte Pulumi avec un token d'accès et de kubectl installés.

Le provider Pulumi OVH prend en charge Go, Python, Node.js/TypeScript, C# et Java. Consultez les exemples.

Définissez les identifiants sous forme de variables d'environnement :

export OVH_ENDPOINT="ovh-eu"
export OVH_APPLICATION_KEY="xxx"
export OVH_APPLICATION_SECRET="xxx"
export OVH_CONSUMER_KEY="xxx"

Créez et initialisez le projet :

mkdir pulumi_ovh_kube && cd pulumi_ovh_kube
pulumi new go -y
go get github.com/ovh/pulumi-ovh/sdk/go/...

Éditez Pulumi.yaml pour ajouter le service name :

config:
 serviceName: <your-service-name>

Éditez main.go :

package main

import (
    "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    "github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
    "github.com/ovh/pulumi-ovh/sdk/go/ovh/cloudproject"
)

func main() {
    pulumi.Run(func(ctx *pulumi.Context) error {
        serviceName := config.Require(ctx, "serviceName")

        myKube, err := cloudproject.NewKube(ctx, "my_desired_cluster", &cloudproject.KubeArgs{
            ServiceName: pulumi.String(serviceName),
            Name:        pulumi.String("my_desired_cluster"),
            Region:      pulumi.String("GRA5"),
        })
        if err != nil {
            return err
        }

        ctx.Export("kubeconfig", pulumi.ToSecret(myKube.Kubeconfig))

        nodePool, err := cloudproject.NewKubeNodePool(ctx, "my-desired-pool", &cloudproject.KubeNodePoolArgs{
            ServiceName:  pulumi.String(serviceName),
            KubeId:       myKube.ID(),
            Name:         pulumi.String("my-desired-pool"),
            DesiredNodes: pulumi.Int(1),
            MaxNodes:     pulumi.Int(3),
            MinNodes:     pulumi.Int(1),
            FlavorName:   pulumi.String("b2-7"),
        })
        if err != nil {
            return err
        }

        ctx.Export("nodePoolID", nodePool.ID())
        return nil
    })
}

Exécutez go mod tidy puis déployez :

pulumi up

Connexion au cluster

Via l'espace client OVHcloud

Via l'API OVHcloud

Via la CLI OVHcloud

Via Terraform

Via CDK pour Terraform

Via Pulumi

Sur la page de votre cluster, ouvrez l'onglet Service et téléchargez le fichier de configuration kubectl pour vous connecter à votre cluster.

Appelez l'endpoint suivant pour récupérer le contenu du kubeconfig et enregistrez-le dans un fichier :

POST/cloud/project/{serviceName}/kube/{kubeId}/kubeconfig

kubectl --kubeconfig=kubeconfig.yaml get nodes

Problèmes connus

« not enough xxx quotas »

Par défaut, les quotas de ressources Public Cloud (RAM, CPU, espace disque, nombre d'instances, etc.) sont limités pour des raisons de sécurité. Si vous manquez de ressources lors de la création d'un pool de nœuds, suivez le guide Augmenter les quotas Public Cloud pour les augmenter.

Via Terraform

Via Pulumi

« gzip: invalid header »

Cette erreur survient lorsque le nom d'un pool de nœuds ou d'une flavor contient _ ou .. Seuls les caractères minuscules, les chiffres et le tiret - sont acceptés :

name        = "my-pool"
flavor_name = "b2-7"

« Provider is missing a required configuration key »

Vous avez oublié d'exporter les variables d'environnement OVHcloud requises :

export OVH_ENDPOINT="ovh-eu"
export OVH_APPLICATION_KEY="xxx"
export OVH_APPLICATION_SECRET="xxx"
export OVH_CONSUMER_KEY="xxx"

« Node pool name xxx is invalid »

Seuls les caractères minuscules, les chiffres et le tiret - sont acceptés dans les noms de pool de nœuds. Renommez votre pool de nœuds avec une valeur valide :

Name: pulumi.String("my-desired-pool"),

Suppression (nettoyage)

Via l'espace client OVHcloud

Via l'API OVHcloud

Via la CLI OVHcloud

Via Terraform

Via CDK pour Terraform

Via Pulumi

Dans la section Managed Kubernetes Service, cliquez sur le bouton ... en regard de votre cluster et sélectionnez Supprimer.

Aller plus loin

Pour avoir une vue d'ensemble du service OVHcloud Managed Kubernetes, rendez-vous sur la page OVHcloud Managed Kubernetes.

Pour déployer votre première application sur votre cluster Kubernetes, nous vous invitons à suivre notre guide de configuration des paramètres par défaut de kubectl et de déploiement d'une application Hello World.

Pour une formation ou une assistance technique sur la mise en œuvre de nos solutions, contactez votre commercial ou consultez la page Professional Services pour obtenir un devis et faire analyser votre projet par nos experts.
Échangez avec notre communauté d'utilisateurs.

Cette page vous a-t-elle aidé ?