Note :

Ce tutoriel nécessite l'accès à Oracle Cloud. Pour vous inscrire à un compte gratuit, voir Introduction à l' niveau gratuit d'Oracle Cloud Infrastructure.
Il utilise des exemples de valeurs pour les données d'identification, la location et les compartiments Oracle Cloud Infrastructure. À la fin de votre laboratoire, remplacez ces valeurs par celles propres à votre environnement en nuage.

Déployer une grappe Kubernetes avec Terraform à l'aide d'Oracle Cloud Infrastructure Kubernetes Engine

Présentation

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 pour gérer les applications conteneurisées dans le nuage. OKE, un service Kubernetes géré par Oracle Cloud Infrastructure, simplifie le déploiement, la gestion et l'évolutivité des grappes Kubernetes.

En utilisant Terraform, un outil d'infrastructure en tant que code (IaC), vous pouvez automatiser le provisionnement et la configuration des grappes OKE, ce qui assure la cohérence et l'efficacité. Cette combinaison permet des déploiements reproductibles, le contrôle des versions de l'infrastructure et des mises à jour faciles, ce qui en fait la solution idéale pour les équipes en nuage natives et axées sur 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és et publics)
2 x groupes de noeuds
4 x noeuds de travail (instances)
Hôte bastion (instance)
Opérateur (instance)

Objectifs

Déployer une grappe Kubernetes avec Terraform à l'aide d'OKE.

Préalables

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, voir 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 d'ici : 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 Démarrage.
1. Notez que vous êtes toujours dans la branche 5.1.8, d'autres branches peuvent contenir différents types d'étape de documentation, selon la version du code.
2. Notez que vous êtes sur la page Démarrage et que cette page fera exactement ce que le titre indique.
Dans la sortie suivante, vous pouvez voir comment nous utilisons la page Démarrage 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 lister 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 lister le contenu du dossier.
Notez que 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
```
Notez que le message : Terraform a été initialisé s'affiche.

Assurez-vous que les informations suivantes sont disponibles pour créer le fichier terraform.tfvars. Ces informations peuvent être extraites à l'aide des étapes suivantes mentionnées ici : Tâche 2 : Préparer votre environnement pour l'authentification et exécuter des scripts Terraform.

OCID de la location	ocid1.tenancy.oc1..aaaaaaaaXXX
OCID de l'utilisateur	ocid1.user.oc1..aaaaaaaaXXX
Empreinte numérique	30:XXX
Région	me-abudhabi-1
Chemin de la clé privée	~/.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 lister le contenu du dossier.
Notez que le fichier terraform.tfvars est créé.

Tâche 2 : Exécuter l'application Terraform et créer une grappe OKE avec les ressources nécessaires (VCN, sous-réseaux, etc.)

Exécutez la commande suivante pour planifier le déploiement de la grappe 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 grappe 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 continuer le déploiement.
Une fois le déploiement terminé, vous verrez un message indiquant 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 : Confirmer le déploiement Terraform dans la console OCI

Naviguez jusqu'à la console OCI et confirmez les déploiements Terraform suivants.

Grappe du moteur Kubernetes d'OCI
- Allez à la console OCI.
  1. Naviguez jusqu'à Services de développement et cliquez sur Grappes Kubernetes (OKE).
  2. Cliquez sur la grappe Kubernetes oke créée dans la tâche 2.
- Faire défiler vers le bas.
  1. Cliquez sur Groupes de noeuds.
  2. Cliquez sur le groupe de noeuds np1.
- Faire défiler vers le bas.
- Notez qu'il existe un noeud de travail dans le groupe de noeuds np1.
- Allez à la page précédente et cliquez sur le groupe de noeuds np2.
- Faire défiler vers le bas.
- Notez que le groupe de noeuds np2 contient trois noeuds de travail.
Instances
- Allez à la console OCI.
  1. Naviguez jusqu'à Calcul et cliquez sur Instances.
  2. Vérifiez les quatre noeuds de traitement de la grappe Kubernetes.
  3. Vérifiez l'opérateur de la grappe Kubernetes.
  4. Vérifiez que l'hôte de l'hôte bastion appartient à la grappe Kubernetes.
Réseau en nuage virtuel
- Allez à la console OCI, naviguez jusqu'à Réseau, Réseaux en nuage virtuels et cliquez sur le VCN oke.
- Cliquez sur Sous-réseaux et vous pouvez voir les sept sous-réseaux de la grappe Kubernetes.
- L'image suivante illustre ce que nous avons créé jusqu'à présent avec le script Terraform.

Tâche 4 : Utiliser l'hôte bastion et l'opérateur 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 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 au moyen de l'hôte 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 la grappe Kubernetes à partir de l'opérateur. Entrez oui deux fois et exécutez la commande kubectl get nodes pour obtenir les noeuds de travail 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 : Supprimer la grappe Kubernetes à l'aide de Terraform

Exécutez la commande terraform destroy pour supprimer la grappe Kubernetes dans OKE.
```
iwhooge@iwhooge-mac tfoke % terraform destroy
```
Entrez oui.

Lorsque le processus de destruction est terminé, vous verrez un message indiquant que la destruction est terminée.

Étapes suivantes

Le déploiement d'une grappe Kubernetes sur OCI Kubernetes Engine à l'aide de Terraform offre une solution efficace, automatisée et évolutive pour gérer les applications en conteneur dans le nuage.

En tirant parti des capacités IaC de Terraform, vous assurez que vos grappes Kubernetes sont déployées de manière cohérente et peuvent être facilement maintenues ou mises à jour au fil du temps.

Cette intégration simplifie le processus, ce qui permet un meilleur contrôle des versions, une mise à l'échelle automatisée et une configuration d'infrastructure reproductible. Que vous gériez une seule grappe ou une mise à l'échelle entre les environnements, cette approche permet aux équipes de gérer leurs charges de travail Kubernetes avec fiabilité et facilité dans Oracle Cloud Infrastructure.

Confirmation

Auteur - Iwan Hoogendoorn (spécialiste du réseau OCI)

Autres ressources d'apprentissage

Explorez d'autres laboratoires sur la page docs.oracle.com/learn ou accédez à plus de contenu d'apprentissage gratuit sur le canal YouTube d'Oracle Learning. De plus, visitez education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir de la documentation sur le produit, visitez Oracle Help Center.

Titre et Copyright

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

G18101-01

October 2024

Oracle et/ou ses sociétés affiliées.