Nota

Questa esercitazione richiede l'accesso a Oracle Cloud. Per iscriverti a un account gratuito, consulta Inizia a utilizzare Oracle Cloud Infrastructure Free Tier.
Utilizza valori di esempio per le credenziali, la tenancy e i compartimenti di Oracle Cloud Infrastructure. Al termine del laboratorio, sostituisci questi valori con quelli specifici del tuo ambiente cloud.

Implementa un cluster Kubernetes con Terraform utilizzando Oracle Cloud Infrastructure Kubernetes Engine

Introduzione

L'implementazione di Kubernetes con Terraform su Oracle Cloud Infrastructure Kubernetes Engine (OCI Kubernetes Engine o OKE) offre un approccio semplificato e scalabile alla gestione delle applicazioni containerizzate nel cloud. OKE, un servizio Kubernetes gestito da Oracle Cloud Infrastructure, semplifica l'implementazione, la gestione e il ridimensionamento dei cluster Kubernetes.

Utilizzando Terraform, uno strumento Infrastructure as Code (IaC), puoi automatizzare il provisioning e la configurazione dei cluster OKE, garantendo coerenza ed efficienza. Questa combinazione consente distribuzioni ripetibili, controllo delle versioni dell'infrastruttura e aggiornamenti semplici, rendendola ideale per i team cloud nativi e focalizzati su DevOps che desiderano sfruttare l'ecosistema Oracle Cloud Infrastructure.

In questa esercitazione verrà distribuita un'architettura Kubernetes molto specifica su OKE OCI utilizzando Terraform.

Verranno distribuiti i seguenti componenti:

Gateway Internet
Gateway NAT
Gateway del servizio
7 x Subnet (private e pubbliche)
2 x pool di nodi
4 x nodi di lavoro (istanze)
Bastion (istanza)
Operatore (istanza)

immagine

Obiettivi

Distribuire un cluster Kubernetes con Terraform utilizzando OKE.

Prerequisiti

Per distribuire gli oggetti su OCI utilizzando Terraform, è innanzitutto necessario preparare l'ambiente per l'autenticazione e l'esecuzione degli script Terraform. Per ulteriori informazioni, vedere Task 2: Preparare l'ambiente per l'autenticazione ed eseguire gli script Terraform.

Task 1: duplicare il repository con gli script Terraform

Duplica il repository terraform-oci-oke da qui: terraform-oci-oke.
1. Al momento di scrivere questo tutorial l'ultima versione è 5.1.8.
2. È possibile scaricare il file zip completo con il repository completo oppure duplicare il repository utilizzando il comando git clone.
3. Fare clic sulla versione per accedere alla diramazione 5.1.8.
1. Si è nella diramazione 5.1.8.
2. Fare clic sulla cartella docs.
Fare clic sulla cartella src.
Fare clic sul file SUMMARY.md.
Fare clic su Introduzione.
1. Si noti che ci si trova ancora nella diramazione 5.1.8, altre diramazioni possono contenere diversi tipi di passi della documentazione a seconda della versione del codice.
2. Si noti che ci si trova nella pagina Guida introduttiva e che questa pagina farà esattamente quello che dice il titolo.
Nell'output riportato di seguito è possibile vedere come viene utilizzata la pagina Guida introduttiva per creare questa esercitazione.
1. Eseguire il comando git clone per duplicare il repository.
```
iwhooge@iwhooge-mac ~ % git clone https://github.com/oracle-terraform-modules/terraform-oci-oke.git tfoke
```
2. Eseguire il comando seguente per modificare la cartella nella cartella del repository.
3. Eseguire il comando seguente per elencare il contenuto della cartella.
4. È possibile visualizzare tutti i file del repository.

Creare un file providers.tf all'interno di questa directory con il contenuto seguente.

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"
}

Eseguire il comando seguente per elencare il contenuto della cartella.
Si noti che viene creato il file providers.tf.

immagine

Eseguire il comando seguente per inizializzare Terraform e aggiornare i moduli necessari.
```
iwhooge@iwhooge-mac tfoke % terraform init --upgrade
```
Si noti che viene visualizzato il messaggio: Terraform è stato inizializzato correttamente.

immagine

Per creare il file terraform.tfvars, assicurarsi di disporre delle seguenti informazioni. Queste informazioni possono essere recuperate utilizzando i passi riportati di seguito. Task 2: preparare l'ambiente per l'autenticazione ed eseguire gli script Terraform.

OCID tenancy	ocid1.tenancy.oc1..aaaaaaaaXXX
OCID utente	ocid1.user.oc1..aaaaaaaaXXX
Impronta	30:XXX
Area	me-abudhabi-1
Percorso chiave privata	~/.oci/4-4-2023-rsa-key.pem
OCID compartimento	ocid1.compartment.oc1..aaaaaaaaXXX

È necessario creare un file terraform.tfvars all'interno di questa directory con il seguente contenuto.

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"

Eseguire il comando seguente per elencare il contenuto della cartella.
Si noti che viene creato il file terraform.tfvars.

immagine

Task 2: eseguire l'applicazione Terraform e creare un cluster OKE con le risorse necessarie (VCN, subnet e così via)

Eseguire il comando riportato di seguito per pianificare la distribuzione del cluster Kubernetes in OKE utilizzando Terraform.
```
iwhooge@iwhooge-mac tfoke % terraform plan
```
1. Tenere presente che questo codice Terraform distribuirà 77 oggetti.
2. Eseguire il comando terraform apply.
Eseguire il comando riportato di seguito per applicare la distribuzione del cluster Kubernetes in OKE utilizzando Terraform.
```
iwhooge@iwhooge-mac tfoke % terraform apply
```
1. Tenere presente che questo codice Terraform distribuirà 77 oggetti.
2. Immettere yes per continuare la distribuzione.
Al termine della distribuzione, verrà visualizzato un messaggio che indica che l'applicazione è stata completata.

Si noti l'output che è stato fornito con informazioni utili che potrebbero essere necessarie per il riferimento.

Output:

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 %

Task 3: confermare la distribuzione di Terraform nella console OCI

Passare a OCI Console e confermare le seguenti distribuzioni Terraform.

Cluster motore Kubernetes OCI
- Andare a OCI Console.
  1. Passare a Servizi per sviluppatori e fare clic su Cluster Kubernetes (OKE).
  2. Fare clic sul cluster Kubernetes oke creato nel task 2.
- scorrere in Basso.
  1. Fare clic su Pool di nodi.
  2. Fare clic sul pool di nodi np1.
- scorrere in Basso.
- Si noti che nel pool di nodi np1 è presente un nodo di lavoro.
- Andare alla pagina precedente e fare clic sul pool di nodi np2.
- scorrere in Basso.
- Si noti che nel pool di nodi np2 sono presenti tre nodi di lavoro.
Istanze
- Andare a OCI Console.
  1. Passare a Calcola e fare clic su Istanze.
  2. Rivedere i quattro nodi worker del cluster Kubernetes.
  3. Rivedere l'operatore del cluster Kubernetes.
  4. Rivedere l'host bastion appartenente al cluster Kubernetes.
Rete cloud virtuale
- Andare alla console OCI, andare a Networking, Reti cloud virtuali e fare clic sulla VCN oke.
- Fare clic su Subnet e sarà possibile visualizzare tutte e sette le subnet del cluster Kubernetes.
- L'immagine riportata di seguito illustra gli elementi creati finora con lo script Terraform.

Task 4: Usa bastion e operatore per verificare la connettività

Nell'output sono disponibili alcuni comandi per connettersi all'ambiente Kubernetes al termine della distribuzione di Terraform.

Eseguire il comando riportato di seguito per connettersi all'host bastion.
```
ssh_to_bastion = "ssh -i ~/.ssh/id_rsa opc@129.xxx.xxx.xxx"
```

Eseguire il comando riportato di seguito per connettersi all'operatore Kubernetes tramite l'host 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"

Gestiamo il cluster Kubernetes dall'operatore. Immettere sì due volte ed eseguire il comando kubectl get nodes per ottenere i nodi di lavoro Kubernetes.

Per semplificare le connessioni SSH, aggiungere i seguenti comandi aggiuntivi nel file ~/.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

Dopo aver aggiunto il contenuto seguente al file ~/.ssh/config, sarà possibile utilizzare nomi semplici nei comandi SSH.

iwhooge@iwhooge-mac tfoke % ssh operator47

immagine

Task 5: eliminare il cluster Kubernetes utilizzando Terraform

Eseguire il comando terraform destroy per eliminare il cluster Kubernetes in OKE.
```
iwhooge@iwhooge-mac tfoke % terraform destroy
```
Immettere yes.

Al termine del processo di eliminazione, verrà visualizzato un messaggio che indica che l'eliminazione è stata completata.

Passi successivi

L'implementazione del cluster Kubernetes su OCI Kubernetes Engine utilizzando Terraform fornisce una soluzione efficiente, automatizzata e scalabile per la gestione delle applicazioni containerizzate nel cloud.

Sfruttando le funzionalità IaC di Terraform, ti assicuri che i tuoi cluster Kubernetes vengano distribuiti in modo coerente e possano essere facilmente gestiti o aggiornati nel tempo.

Questa integrazione semplifica il processo, consentendo un migliore controllo della versione, una scalabilità automatizzata e una configurazione dell'infrastruttura ripetibile. Indipendentemente dal fatto che tu gestisca un singolo cluster o il ridimensionamento in tutti gli ambienti, questo approccio consente ai team di gestire i carichi di lavoro Kubernetes con affidabilità e facilità in Oracle Cloud Infrastructure.

Conferme

Autore - Iwan Hoogendoorn (esperto di rete OCI)

Altre risorse di apprendimento

Esplora altri laboratori su docs.oracle.com/learn o accedi a più contenuti gratuiti sulla formazione su Oracle Learning YouTube channel. Inoltre, visita education.oracle.com/learning-explorer per diventare un Oracle Learning Explorer.

Per la documentazione del prodotto, visita l'Oracle Help Center.

Titolo e informazioni sul copyright

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

G18103-01

October 2024

Oracle e/o relative consociate.