Remarques :

Ce tutoriel nécessite un accès à Oracle Cloud. Pour vous inscrire à un compte gratuit, reportez-vous à Introduction au niveau gratuit d'Oracle Cloud Infrastructure.
Il utilise des exemples de valeurs pour les informations d'identification, la location et les compartiments Oracle Cloud Infrastructure. Lorsque vous terminez votre atelier, remplacez ces valeurs par celles propres à votre environnement cloud.

Déployer un cluster Kubernetes avec Terraform à l'aide d'Oracle Cloud Infrastructure Kubernetes Engine

Introduction

Le déploiement de Kubernetes avec Terraform sur Oracle Cloud Infrastructure Kubernetes Engine (OCI Kubernetes Engine ou OKE) offre une approche rationalisée et évolutive de la gestion des applications en conteneur dans le cloud. OKE, un service Kubernetes géré sur Oracle Cloud Infrastructure, simplifie le déploiement, la gestion et la mise à l'échelle des clusters Kubernetes.

Grâce à Terraform, outil Infrastructure-as-Code (IaC), vous pouvez automatiser le provisionnement et la configuration des clusters OKE, pour assurer la cohérence et l'efficacité. Cette combinaison permet des déploiements reproductibles, la gestion des versions d'infrastructure et des mises à jour faciles, ce qui la rend idéale pour les équipes cloud natives et DevOps qui cherchent à tirer parti de l'écosystème Oracle Cloud Infrastructure.

Dans ce tutoriel, nous allons déployer une architecture Kubernetes très spécifique sur OCI OKE à l'aide de Terraform.

Nous allons déployer les composants suivants :

Passerelle Internet
Passerelle NAT
Passerelle de service
7 x sous-réseaux (privé et public)
2 x pools de noeuds
4 x Noeuds de processus actif (Instances)
Bastion (instance)
Opérateur (instance)

Objectifs

Déployez un cluster Kubernetes avec Terraform avec OKE.

Prérequis

Pour déployer des objets sur OCI à l'aide de Terraform, vous devez d'abord préparer votre environnement pour l'authentification et l'exécution de scripts Terraform. Pour plus d'informations, reportez-vous à Tâche 2 : préparer votre environnement pour l'authentification et exécuter des scripts Terraform.

Tâche 1 : cloner le référentiel à l'aide des scripts Terraform

Clonez le référentiel terraform-oci-oke à partir de cet emplacement : terraform-oci-oke.
1. Au moment de la rédaction de ce tutoriel, la dernière version est 5.1.8.
2. Vous pouvez télécharger le fichier ZIP complet avec le référentiel complet ou cloner le référentiel à l'aide de la commande git clone.
3. Cliquez sur la version pour accéder à la branche 5.1.8.
1. Notez que vous êtes dans la branche 5.1.8.
2. Cliquez sur le dossier docs.
Cliquez sur le dossier src.
Cliquez sur le fichier SUMMARY.md.
Cliquez sur Mise en route.
1. Notez que vous êtes toujours dans la branche 5.1.8, d'autres branches peuvent contenir différents types d'étapes de documentation en fonction de la version de code.
2. Notez que vous êtes sur la page Mise en route et que cette page fera exactement ce que le titre dit.
Dans la sortie suivante, vous pouvez voir comment nous utilisons la page Mise en route pour créer ce tutoriel.
1. Exécutez la commande git clone pour cloner le référentiel.
```
iwhooge@iwhooge-mac ~ % git clone https://github.com/oracle-terraform-modules/terraform-oci-oke.git tfoke
```
2. Exécutez la commande suivante pour transformer le dossier en dossier de référentiel.
3. Exécutez la commande suivante pour répertorier le contenu du dossier.
4. Vous pouvez voir tous les fichiers du référentiel.

Créez un fichier providers.tf dans ce répertoire avec le contenu suivant.

providers.tf:

provider "oci" {
  fingerprint      = var.api_fingerprint
  private_key_path = var.api_private_key_path
  region           = var.region
  tenancy_ocid     = var.tenancy_id
  user_ocid        = var.user_id
}

provider "oci" {
  fingerprint      = var.api_fingerprint
  private_key_path = var.api_private_key_path
  region           = var.home_region
  tenancy_ocid     = var.tenancy_id
  user_ocid        = var.user_id
  alias            = "home"
}

Exécutez la commande suivante pour répertorier le contenu du dossier.
Le fichier providers.tf est créé.

Exécutez la commande suivante pour initialiser Terraform et mettre à niveau les modules requis.
```
iwhooge@iwhooge-mac tfoke % terraform init --upgrade
```
Le message Initialisation réussie de Terraform apparaît.

Assurez-vous que vous disposez des informations suivantes pour créer le fichier terraform.tfvars. Vous pouvez extraire ces informations en procédant comme suit : Tâche 2 : préparer votre environnement pour l'authentification et exécuter des scripts Terraform.

OCID de location	ocid1.tenancy.oc1..aaaaaaaaXXX
OCID utilisateur	ocid1.user.oc1..aaaaaaaaXXX
Empreinte	30:XXX
Région	me-abudhabi-1
Private Key Path	~/.oci/4-4-2023-rsa-key.pem
OCID du compartiment.	ocid1.compartment.oc1..aaaaaaaaXXX

Nous devons créer un fichier terraform.tfvars dans ce répertoire avec le contenu suivant.

terraform.tfvars:

# Identity and access parameters
api_fingerprint      = "30:XXX"
api_private_key_path = "~/.oci/4-4-2023-rsa-key.pem"

home_region = "me-abudhabi-1"
region      = "me-abudhabi-1"
tenancy_id  = "ocid1.tenancy.oc1..aaaaaaaaXXX"
user_id     = "ocid1.user.oc1..aaaaaaaaXXX"

# general oci parameters
compartment_id = "ocid1.compartment.oc1..aaaaaaaaXXX"
timezone       = "Australia/Sydney"

# ssh keys
ssh_private_key_path = "~/.ssh/id_rsa"
ssh_public_key_path  = "~/.ssh/id_rsa.pub"

# networking
create_vcn               = true
assign_dns               = true
lockdown_default_seclist = true
vcn_cidrs                = ["10.0.0.0/16"]
vcn_dns_label            = "oke"
vcn_name                 = "oke"

# Subnets
subnets = {
  bastion  = { newbits = 13, netnum = 0, dns_label = "bastion", create="always" }
  operator = { newbits = 13, netnum = 1, dns_label = "operator", create="always" }
  cp       = { newbits = 13, netnum = 2, dns_label = "cp", create="always" }
  int_lb   = { newbits = 11, netnum = 16, dns_label = "ilb", create="always" }
  pub_lb   = { newbits = 11, netnum = 17, dns_label = "plb", create="always" }
  workers  = { newbits = 2, netnum = 1, dns_label = "workers", create="always" }
  pods     = { newbits = 2, netnum = 2, dns_label = "pods", create="always" }
}

# bastion
create_bastion           = true
bastion_allowed_cidrs    = ["0.0.0.0/0"]
bastion_user             = "opc"

# operator
create_operator                = true
operator_install_k9s           = true


# iam
create_iam_operator_policy   = "always"
create_iam_resources         = true

create_iam_tag_namespace = false // true/*false
create_iam_defined_tags  = false // true/*false
tag_namespace            = "oke"
use_defined_tags         = false // true/*false

# cluster
create_cluster     = true
cluster_name       = "oke"
cni_type           = "flannel"
kubernetes_version = "v1.29.1"
pods_cidr          = "10.244.0.0/16"
services_cidr      = "10.96.0.0/16"

# Worker pool defaults
worker_pool_size = 0
worker_pool_mode = "node-pool"

# Worker defaults
await_node_readiness     = "none"

worker_pools = {
  np1 = {
    shape              = "VM.Standard.E4.Flex",
    ocpus              = 2,
    memory             = 32,
    size               = 1,
    boot_volume_size   = 50,
    kubernetes_version = "v1.29.1"
  }
  np2 = {
    shape            = "VM.Standard.E4.Flex",
    ocpus            = 2,
    memory           = 32,
    size             = 3,
    boot_volume_size = 150,
    kubernetes_version = "v1.30.1"
  }
}

# Security
allow_node_port_access       = false
allow_worker_internet_access = true
allow_worker_ssh_access      = true
control_plane_allowed_cidrs  = ["0.0.0.0/0"]
control_plane_is_public      = false
load_balancers               = "both"
preferred_load_balancer      = "public"

Exécutez la commande suivante pour répertorier le contenu du dossier.
Le fichier terraform.tfvars est créé.

Tâche 2 : exécution de Terraform Apply et création d'un cluster OKE avec les ressources nécessaires (VCN, sous-réseaux, etc.)

Exécutez la commande suivante pour planifier le déploiement de cluster Kubernetes sur OKE à l'aide de Terraform.
```
iwhooge@iwhooge-mac tfoke % terraform plan
```
1. Notez que ce code Terraform déploiera 77 objets.
2. Exécutez la commande terraform apply.
Exécutez la commande suivante pour appliquer le déploiement de cluster Kubernetes sur OKE à l'aide de Terraform.
```
iwhooge@iwhooge-mac tfoke % terraform apply
```
1. Notez que ce code Terraform déploiera 77 objets.
2. Entrez yes pour poursuivre le déploiement.
Une fois le déploiement terminé, un message vous indique que l'application est terminée.

Notez la sortie qui a été fournie avec des informations utiles dont vous pourriez avoir besoin pour votre référence.

Sorties:

apiserver_private_host = "10.0.0.22"

availability_domains = tomap({

  "1" = "cAtJ:ME-ABUDHABI-1-AD-1"

})

bastion_id = "ocid1.instance.oc1.me-abudhabi-1.anqxkljrpkxxxxxx5chephxjadkxqa2ekxksb5gokj4q"

bastion_nsg_id = "ocid1.networksecuritygroup.oc1.me-abudhabi-1.aaaaaxxxxxxxxxxxy5qm22odw7by37h77ki6cosoqd7pzwq"

bastion_public_ip = "129.151.149.237"

bastion_subnet_cidr = "10.0.0.0/29"

bastion_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaxxxxxxxxxxxxxxxxmyzp6f2czibfr6534evfkt7m2a"

cluster_endpoints = tomap({

  "kubernetes" = ""

  "private_endpoint" = "10.0.0.22:6443"

  "public_endpoint" = ""

  "vcn_hostname_endpoint" = "cbyedhyevbq.cp.oke.oraclevcn.com:6443"

})

cluster_id = "ocid1.cluster.oc1.me-abudhabi-1.aaaaaaaxxxxxxxxxxxxx57gz5q26hmpzkbcbyedhyevbq"

control_plane_nsg_id = "ocid1.networksecuritygroup.oc1.me-abudhabi-1.aaaaaaaavxvgoewcgxxxxxxxxxxxxx6psycdz6zz5gaf6re4kcxa"

control_plane_subnet_cidr = "10.0.0.16/29"

control_plane_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaajvvpdmuixxxxxxxxxxxjkpx77hqu3v2s4qilnp56a"

dynamic_group_ids = tolist([

  "ocid1.dynamicgroup.oc1..aaaaaaaafsikvwgexxxxxxxxx5tx2u4c2s2eic4sslwyabva",

])

ig_route_table_id = "ocid1.routetable.oc1.me-abudhabi-1.aaaaaaaalxxxxxxxxxxxxxxcyzrl2af4ihrkhcjttu2w7aq"

int_lb_nsg_id = "ocid1.networksecuritygroup.oc1.me-abudhabi-1.aaaaaaaanwppaafc7fyiwcoyhjxxxxxxxxxxxxxxxxx6a6752l7547gxg7ea"

int_lb_subnet_cidr = "10.0.2.0/27"

int_lb_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaawo5xmcwwbzk3gxxxxxxxxxxxxxxxxxxjjfllbvsdauaq"

lpg_all_attributes = {}

nat_route_table_id = "ocid1.routetable.oc1.me-abudhabi-1.aaaaaaaapqn3uqtszdcxxxxxxxxxxxxxxxxxliwveow232xgffigq"

operator_id = "ocid1.instance.oc1.me-abudhabi-1.anqxkljrpkbrwsac5exxxxxxxxxxxxxxxxxxxxxxxrfdxsjdfzmq56jja"

operator_nsg_id = "ocid1.networksecuritygroup.oc1.me-abudhabi-1.aaaaaaaao5kh3z3eaf4zhbtxixxxxxxxxxxxxxxxxxxxxxevyds3cbrjqzthv5ja"

operator_private_ip = "10.0.0.14"

operator_subnet_cidr = "10.0.0.8/29"

operator_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaa6vnirazbox2edmtnxrzhxxxxxxxxxxxxxxxxxxxishk7556iw6zyq"

pod_subnet_cidr = "10.0.128.0/18"

pod_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaasfnwg3lnyphk5h275r46ksi3xxxxxxxxxxxxxxxxxxxxxxxqz25iwkcinxa"

policy_statements = tolist([

  "Allow dynamic-group oke-operator-lccwyk to MANAGE clusters in compartment id ocid1.compartment.oc1..aaaaaaaa323ijv54zwkwbz2hhr2nnqoywlpxxxxxxxxxxxxxxxxxxxxxxxtecokaq4h4a",

])

pub_lb_nsg_id = "ocid1.networksecuritygroup.oc1.me-abudhabi-1.aaaaaaaae5stez5u26g6x75dy5nf72mfcixxxxxxxxxxxxxxxxxxxxxxxx2nwkwv5nkaa"

pub_lb_subnet_cidr = "10.0.2.32/27"

pub_lb_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaagr5j2l6tu3rmroejg6t4nrixxxxxxxxxx6oar6xcirvq"

ssh_to_bastion = "ssh -i ~/.ssh/id_rsa opc@129.xxx.xxx.xxx"

ssh_to_operator = "ssh -o ProxyCommand='ssh -W %h:%p -i ~/.ssh/id_rsa opc@129.xxx.xxx.xxx' -i ~/.ssh/id_rsa opc@10.0.0.14"

state_id = "lccwyk"

vcn_id = "ocid1.vcn.oc1.me-abudhabi-1.amaaaaaapkbrwsaatndqrw3xq7e7krqfxxxxxxxxxxxxxxxpywz4qvhida"

worker_nsg_id = "ocid1.networksecuritygroup.oc1.me-abudhabi-1.aaaaaaaazbpfavygiv4xy3khfi7cxunixxxxxxxxxxxxxxxxjvsm6jqtja"

worker_pool_ids = {

  "np1" = "ocid1.nodepool.oc1.me-abudhabi-1.aaaaaaaauo57ekyoiiaif25gq7uwrpxxxxxxxxxxxxxxpsnygeam7t2wa"

  "np2" = "ocid1.nodepool.oc1.me-abudhabi-1.aaaaaaaa7423cp6zyntxwxokol3kmdxxxxxxxxxxxxx3wnayv2xq6nyq"

}

worker_pool_ips = {

  "np1" = {

    "ocid1.instance.oc1.me-abudhabi-1.anqxkljrpkbrwsac3t3smjsyxjgen4zqjpxxxxxxxxxxxxx663igu7cznla" = "10.0.90.37"

  }

  "np2" = {

    "ocid1.instance.oc1.me-abudhabi-1.anqxkljrpkbrwsac2eayropnzgazrxxxxxxxxxxxxxxxxpiykrq4r5pbga" = "10.0.125.238"

    "ocid1.instance.oc1.me-abudhabi-1.anqxkljrpkbrwsace4aup47ukjcedxxxxxxxxxxxxxxxxxx2hdxbsyiitva" = "10.0.92.136"

    "ocid1.instance.oc1.me-abudhabi-1.anqxkljrpkbrwsacojjri4b7qsaxxxxxxxxxxxxxxxxxnarf75ejv7a2a" = "10.0.111.157"

  }

}

worker_subnet_cidr = "10.0.64.0/18"

worker_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaarrnazbrmwbiyl3ljmdxhgmxxxxxxxxxxxxxxxxxxxv3wtgmiucnsa"

iwhooge@iwhooge-mac tfoke %

Tâche 3 : confirmation du déploiement Terraform dans la console OCI

Accédez à la console OCI et confirmez les déploiements Terraform suivants.

Cluster de moteur Kubernetes OCI
- Accédez à la console OCI.
  1. Accédez à Services de développeur et cliquez sur Clusters Kubernetes (OKE).
  2. Cliquez sur le cluster Kubernetes oke créé dans la tâche 2.
- Défiler vers le bas.
  1. Cliquez sur Pools de noeuds.
  2. Cliquez sur le pool de noeuds np1.
- Défiler vers le bas.
- Notez qu'il existe un noeud de processus actif dans le pool de noeuds np1.
- Accédez à la page précédente et cliquez sur le pool de noeuds np2.
- Défiler vers le bas.
- Le pool de noeuds np2 contient trois noeuds de processus actif.
Instances
- Accédez à la console OCI.
  1. Accédez à Compute et cliquez sur Instances.
  2. Vérifiez les quatre noeuds de processus actif du cluster Kubernetes.
  3. Vérifiez l'opérateur du cluster Kubernetes.
  4. Vérifiez que l'hôte de bastion appartient au cluster Kubernetes.
Réseau cloud virtuel
- Accédez à la console OCI, accédez à Fonctions de réseau, à Réseaux cloud virtuels et cliquez sur le VCN oke.
- Cliquez sur Sous-réseaux pour afficher les sept sous-réseaux du cluster Kubernetes.
- L'image suivante illustre ce que nous avons créé jusqu'à présent avec le script Terraform.

Tâche 4 : utilisation de Bastion et d'Operator pour vérifier la connectivité

Dans la sortie, vous trouverez des commandes pour vous connecter à votre environnement Kubernetes une fois le déploiement Terraform terminé.

Exécutez la commande suivante pour vous connecter à l'hôte de bastion.
```
ssh_to_bastion = "ssh -i ~/.ssh/id_rsa opc@129.xxx.xxx.xxx"
```

Exécutez la commande suivante pour vous connecter à l'opérateur Kubernetes via l'hôte de bastion.

ssh_to_operator = "ssh -o ProxyCommand='ssh -W %h:%p -i ~/.ssh/id_rsa opc@129.xxx.xxx.xxx' -i ~/.ssh/id_rsa opc@10.0.0.14"

Nous allons gérer le cluster Kubernetes à partir de l'opérateur. Entrez yes deux fois et exécutez la commande kubectl get nodes pour obtenir les noeuds de processus actif Kubernetes.

Pour faciliter les connexions SSH, ajoutez les commandes supplémentaires suivantes dans votre fichier ~/.ssh/config.

Host bastion47
    HostName 129.xxx.xxx.xxx
    user opc
    IdentityFile ~/.ssh/id_rsa
    UserKnownHostsFile /dev/null
    StrictHostKeyChecking=no
    TCPKeepAlive=yes
    ServerAliveInterval=50

Host operator47
    HostName 10.0.0.14
    user opc
    IdentityFile ~/.ssh/id_rsa
    ProxyJump bastion47
    UserKnownHostsFile /dev/null
    StrictHostKeyChecking=no
    TCPKeepAlive=yes
    ServerAliveInterval=50

Après avoir ajouté le contenu suivant au fichier ~/.ssh/config, vous pourrez utiliser des noms simples dans les commandes SSH.

iwhooge@iwhooge-mac tfoke % ssh operator47

Tâche 5 : suppression du cluster Kubernetes à l'aide de Terraform

Exécutez la commande terraform destroy pour supprimer le cluster Kubernetes dans OKE.
```
iwhooge@iwhooge-mac tfoke % terraform destroy
```
Saisissez yes.

Une fois le processus de destruction terminé, un message indiquant que la destruction est terminée s'affiche.

Etapes suivantes

Le déploiement d'un cluster Kubernetes sur OCI Kubernetes Engine à l'aide de Terraform fournit une solution efficace, automatisée et évolutive pour la gestion d'applications en conteneur dans le cloud.

En exploitant les fonctionnalités IaC de Terraform, vous garantissez que vos clusters Kubernetes sont déployés de manière cohérente et peuvent être facilement maintenus ou mis à jour au fil du temps.

Cette intégration rationalise le processus, permettant un meilleur contrôle des versions, une mise à l'échelle automatisée et une configuration d'infrastructure reproductible. Que vous gériez un seul cluster ou que vous fassiez évoluer d'un environnement à l'autre, cette approche permet aux équipes de gérer leurs charges de travail Kubernetes avec fiabilité et facilité dans Oracle Cloud Infrastructure.

Remerciements

Auteur - Iwan Hoogendoorn (Spécialiste réseau OCI)

Ressources de formation supplémentaires

Explorez d'autres ateliers sur docs.oracle.com/learn ou accédez à d'autres contenus de formation gratuits sur le canal Oracle Learning YouTube. De plus, visitez le site education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir la documentation produit, consultez le site Oracle Help Center.

Informations relatives au titre et au copyright

Deploy a Kubernetes Cluster with Terraform using Oracle Cloud Infrastructure Kubernetes Engine

G18102-01

October 2024

Oracle et/ou ses affiliés.