Déployer Oracle Cloud Infrastructure Kubernetes Engine (OKE) à l'aide de modules Terraform avancés

Introduction

Il s'agit du deuxième tutoriel de notre série d'automatisation Oracle Cloud Infrastructure Kubernetes Engine (OKE), qui s'appuie sur les concepts de base du premier, Créer un cluster Oracle Cloud Infrastructure Kubernetes Engine à l'aide de Terraform. Dans cet article, nous faisons passer les déploiements OKE au niveau supérieur en introduisant une automatisation avancée et une conception modulaire pour provisionner des environnements évolutifs, résilients et hautement personnalisables sur Oracle Cloud Infrastructure (OCI).

Conçu pour les ingénieurs et les clients Oracle, ce guide vous permet de transformer une configuration Terraform de base en un module structuré et réutilisable qui peut être adapté à toute taille de déploiement. En tirant parti des principes d'infrastructure en tant que code (IaC) avec Terraform (version de communauté), associés à Jenkins et à l'interface de ligne de commande (CLI) d'Oracle, nous fournissons une solution de provisionnement single-click pour les clusters OKE, leurs configurations et les tests automatisés.

Ce tutoriel se concentre sur quatre domaines clés :

  1. Conception et automatisation modulaires : créez des modules réutilisables pour les composants de base tels que VCN, les clusters OKE et les hôtes Bastion, avec la gestion des versions pour assurer la compatibilité afin de simplifier la gestion et de promouvoir la réutilisation du code.
  2. Configuration dynamique : gérez les paramètres propres à l'environnement (dev, test, prod) à partir d'une base de code unique pour des déploiements cohérents et reproductibles.
  3. Pools de noeuds avancés : optimisez l'utilisation des ressources et les coûts avec des formes spécialisées, des images OKE compatibles et des libellés pour le placement intelligent des charges de travail.
  4. Intégration continue et continue transparente : automatisez le provisionnement et les mises à jour OKE à l'aide de pipelines qui intègrent Terraform, Jenkins et l'interface de ligne de commande OCI pour des déploiements one-click efficaces.

L'architecture décrite dans ce guide utilise une topologie réseau à plusieurs niveaux pour créer une base sécurisée et évolutive. Il sépare le trafic du plan de contrôle, des noeuds de processus actif et des équilibreurs de charge, ce qui garantit une flexibilité pour les charges de travail d'entreprise à toute échelle. Nous montrerons comment automatiser entièrement le provisionnement d'un tel environnement, y compris la mise en réseau, les clusters et les pools de noeuds, tout en fournissant les outils nécessaires pour personnaliser et étendre la solution à vos besoins.

Ce tutoriel suppose une compréhension des principes Kubernetes, de réseau et IaC, ainsi qu'une connaissance pratique des outils tels que Terraform, l'interface de ligne de commande OCI et Jenkins. À la fin, vous aurez les compétences nécessaires pour déployer un environnement OKE résilient, performant et évolutif sur OCI, avec la flexibilité de l'adapter à vos exigences spécifiques.

Présentation d'Oracle Cloud Infrastructure Kubernetes Engine (OKE)

Même si Oracle Cloud Infrastructure Kubernetes Engine (OKE) est un service géré, l'exécution réussie de charges de travail critiques nécessite une approche architecturale délibérée et bien structurée. Le passage d'une configuration de base à un environnement évolutif et adapté à l'entreprise exige une planification minutieuse et l'utilisation d'outils Infrastructure-as-Code (IaC) tels que Terraform.

La modularisation et l'automatisation sont essentielles pour OKE afin de garantir l'évolutivité, la sécurité et l'efficacité opérationnelle. En tirant parti de modules structurés et d'outils d'automatisation, les entreprises peuvent déployer et gérer des charges de travail critiques de manière cohérente, réduire les erreurs manuelles et accélérer la mise sur le marché.

Le diagramme suivant illustre l'architecture OKE, en mettant en évidence sa topologie de réseau hiérarchisé, son adresse d'API privée et ses contrôles d'accès sécurisé :

Architecture OKE

Pour obtenir un exemple détaillé de l'architecture, reportez-vous à la documentation Oracle.

Considérations architecturales
La création d'un environnement OKE évolutif implique de relever au moins les principaux défis techniques suivants :

Eléments de conception clés
Cette solution modulaire s'appuie sur une architecture réseau à plusieurs niveaux, fournissant une base sécurisée et évolutive pour les charges de travail d'entreprise sur OKE :

Création d'une automatisation modulaire de Terraform pour OKE

La transformation d'une configuration flat Terraform en une configuration structured est essentielle pour créer des environnements répétables et évolutifs. Cette approche garantit une meilleure organisation, une meilleure réutilisabilité du code et une meilleure maintenabilité à l'échelle de l'entreprise, avec la gestion des versions pour assurer la compatibilité et la collaboration entre les équipes.

Processus de transformation : module plat à structuré

A partir du module plat décrit dans le premier tutoriel, nous transformons le code en une conception modulaire en :

  1. Restructuration du répertoire : créez des modules enfant (vcn, oke, bastion) et organisez les ressources dans leurs dossiers respectifs.
  2. Application de principes clés :
    • Structure et logique : encapsulez les ressources dans des répertoires autonomes (par exemple, modules/vcn, modules/oke, modules/bastion) et divisez le code monolithique en main.tf, variables.tf et outputs.tf pour plus de lisibilité et de facilité de maintenance.
    • Entrées/Sorties et gestion des versions : définissez les entrées dans variables.tf, affichez les sorties dans outputs.tf et utilisez la gestion des versions du module Terraform (contrainte version dans source) pour un flux de données et une compatibilité transparents.
    • Orchestration : gérez la logique conditionnelle telle que count au niveau du module racine, en gardant les modules enfants concentrés sur leurs ressources.

Structure de répertoires : plate ou modulaire

Module plat : répertoire monolithique unique contenant toutes les ressources dans quelques fichiers. Simple pour les preuves de concept, mais devient ingérable à mesure que la complexité augmente.

Structure de module plat

Module structuré : chaque groupe de ressources (VCN, OKE, Bastion) se trouve dans son propre répertoire de modules. Le module racine orchestre les dépendances et la configuration de niveau supérieur.

Structure de module avancée

Exemples de modules

Présentation des modules

Orchestration de modules - racine main.tf

La racine main.tf orchestre le déploiement de trois modules clés (modules/vcn, modules/oke et modules/bastion) de manière séquentielle. Chaque module est appelé de manière conditionnelle en fonction d'indicateurs de configuration (is_vcn_created, is_oke_created, is_bastion_created), ce qui permet une certaine flexibilité dans le déploiement. Vous trouverez ci-dessous une version simplifiée du flux d'orchestration, mettant en évidence la logique du module clé sans détailler l'intégralité du fichier main.tf.

Flux d'orchestration :

  1. Module VCN (modules/vcn) :
    • Fournit le réseau cloud virtuel (VCN) et les sous-réseaux associés (par exemple, sous-réseaux privés pour l'API Kubernetes et les noeuds de processus actif, sous-réseaux publics pour les équilibreurs de charge et le bastion).
    • Contrôle par is_vcn_created. S'il est activé, il crée le VCN ; sinon, il suppose un VCN existant (vous devez fournir son OCID de sous-réseau utilisé).
    • Exemple de fragment de code : 
         module "vcn" {
       count = var.is_vcn_created ? 1 : 0  
       source = "./modules/vcn?ref=v1.0.0"  # Specify the module version  
       # Key variables: compartment_id, vcn_cidr_block, subnet configs, ...  
   }
  2. Module OKE (modules/oke) :
    • Déploie le cluster OCI Kubernetes Engine (OKE), y compris le plan de contrôle et les pools de noeuds gérés facultatifs.
    • Dépend du module VCN pour les ID de sous-réseau. Appelé uniquement si is_oke_created et is_vcn_created ont la valeur True.
    • Exemple de fragment de code : 
         module "oke" {
       count = var.is_oke_created && var.is_vcn_created ? 1 : 0  
       source = "./modules/oke?ref=v1.0.0"  # Specify the module version   
       # Key variables: vcn_id, subnet IDs, k8 version, node pool config, ...  
   }
  3. Module de bastion (modules/bastion) :
    • Crée un bastion pour un accès SSH sécurisé aux ressources privées.
    • Dépend du module VCN pour l'ID de sous-réseau public. Appelé uniquement si is_bastion_created et is_vcn_created ont la valeur True.
    • Exemple de fragment de code : 
         module "bastion" {
       count = var.is_bastion_created && var.is_vcn_created ? 1 : 0  
       source = "./modules/bastion?ref=v1.0.0"  # Specify the module version   
       # Key variables: bastion_subnet_id, SSH keys, parameters...  
   }

      Remarques importantes :

    • Dépendances de module : les sorties du module VCN telles que module.vcn[0].vcn_id sont transmises en tant qu'entrées aux modules OKE et Bastion, ce qui garantit une chaîne de dépendance claire.
    • Logique de configuration : les mappings de paramètres simplifiés (par exemple, node_pool_param, bastion_params) rationalisent la configuration et la lisibilité.
    • Gestion des versions : l'utilisation des contraintes de version dans source garantit que les modules sont déployés avec les versions correctes et testées, ce qui garantit la compatibilité

Après avoir établi une structure Terraform modulaire pour OKE, l'étape suivante consiste à automatiser son déploiement. L'automatisation garantit la cohérence, réduit les erreurs manuelles, accélère le processus de provisionnement et améliore directement le délai de mise sur le marché en permettant la livraison rapide de nouvelles fonctionnalités et de nouveaux services.

Options d'automatisation

Plusieurs outils peuvent automatiser les déploiements OKE, notamment l'interface de ligne de commande Terraform, OCI Resource Manager (ORM), l'interface de ligne de commande OCI, les modules Ansible OCI et Helm. Cependant, ce guide se concentre sur les deux approches d'infrastructure en tant que code (IaC) les plus importantes dans Oracle Cloud Infrastructure (OCI) : CLI Terraform et OCI Resource Manager (ORM).

Les deux outils utilisent le même langage de configuration déclaratif HashiCorp (HCL), mais diffèrent dans leurs modèles opérationnels :

Explorons chaque option en détail.

Option 1 : déploiement de ressources OKE avec l'interface de ligne de commande Terraform

L'interface de ligne de commande Terraform est idéale lorsque vous avez besoin d'un contrôle total sur votre environnement local. Il convient mieux aux développeurs individuels ou aux petites équipes qui peuvent gérer le fichier d'état et collaborer efficacement à l'aide d'un back-end partagé. Sa portabilité vous permet de l'exécuter à partir de n'importe quelle machine : les programmes d'exécution locaux, de machine virtuelle, de conteneur, d'OCI CloudShell ou d'intégration continue et de déploiement continu tels que Jenkins. Toutefois, cette flexibilité s'accompagne de responsabilités telles que la gestion des fichiers d'état et la cohérence des configurations locales entre les membres de l'équipe.

Pour commencer, téléchargez et décompressez le package de code source de l'interface de ligne de commande Terraform dans votre répertoire de travail Terraform. Ce package inclut main.tf, un exemple terraform.tfvars et des configurations de module détaillées : téléchargez oke_advanced_module.zip.

Le déploiement d'OKE avec l'interface de ligne de commande Terraform implique sept tâches clés, de la configuration des variables et de la mise en réseau à la configuration du cluster OKE, des pools de noeuds et de l'hôte de bastion. Voici les étapes détaillées permettant de provisionner et de vérifier votre environnement OKE à l'aide de l'interface de ligne de commande Terraform.

Tâche 1.1 : configurer les variables Terraform

Mettez à jour le fichier terraform.tfvars avec des détails propres à l'environnement tels que tenancy_ocid, la région, compartment_ocid et network_compartment_ocid. Activez les indicateurs suivants pour contrôler la création des ressources :

Tâche 1.2 : Configuration réseau

Définissez des blocs CIDR pour le VCN et ses sous-réseaux :

Tâche 1.3 : Configuration du cluster OKE

Tâche 1.4 : Configuration du pool de noeuds

Configuration de l'hôte du bastion de la tâche 1.5

Tâche 1.6 : exécuter les commandes Terraform

Exécutez les commandes suivantes pour déployer l'infrastructure :

	terraform init
	terraform plan
	terraform apply

Une fois terraform apply terminé, le cluster OKE sera provisionné avec les éléments suivants :

Tâche 1.7 : Vérification

  1. Accédez à la console OCI pour vérifier la configuration du cluster.
  2. Exécutez terraform destroy pour nettoyer les ressources lorsque vous avez terminé.

Automatisation du déploiement OKE avec le pipeline d'intégration continue et de déploiement continu Jenkins
Pour intégrer le déploiement OKE dans les pipelines DevOps, l'interface de ligne de commande Terraform est un excellent choix. Notre approche, détaillée dans Création d'un cluster Oracle Cloud Infrastructure Kubernetes Engine à l'aide de Terraform, utilise des scripts bash pour orchestrer le processus. Ce workflow peut être consolidé dans un pipeline Jenkins pour une exécution automatisée.

Option 2 : automatisation d'OKE avec OCI Resource Manager

OCI Resource Manager (ORM) est le choix idéal lorsque vous avez besoin d'une solution cloud native gérée pour les déploiements d'infrastructure. Il est particulièrement adapté aux environnements d'entreprise collaboratifs où la sécurité, la gestion centralisée de l'état et la gouvernance sont essentielles. L'avantage principal d'ORM est qu'il gère l'ensemble du cycle de vie du déploiement au sein d'OCI, en stockant en toute sécurité le fichier d'état et en prévenant les conflits. Cela élimine le besoin de configuration locale ou de gestion d'un back-end partagé. En outre, l'intégration profonde d'ORM à Oracle Cloud lui permet d'exploiter des fonctionnalités natives d'OCI telles qu'Identity and Access Management (IAM), améliorant ainsi la sécurité et le contrôle.

Dans ce tutoriel, nous combinons OCI Resource Manager (ORM) avec l'interface de ligne de commande OCI, Bash, et les intégrons dans les pipelines d'intégration continue et de déploiement continu Jenkins, offrant un flux d'automatisation one-click complet avec des fonctionnalités DevOps supplémentaires telles que la détection des dérives, la gestion sécurisée des états et la collaboration d'équipe avec la gestion des versions à des fins de compatibilité.

Flux OCI Resource Manager
Le diagramme suivant illustre le workflow ORM, composé de sept étapes :
Workflow ORM

  1. Configuration source : définit l'origine de la configuration IaC (par exemple, OCI Object Storage, GitHub, fichier ZIP).
  2. Modèle Terraform : l'infrastructure est définie à l'aide de Terraform.
  3. OCI Resource Manager : ORM prend le modèle Terraform et gère le processus de provisionnement.
  4. Créer une pile : ORM utilise le modèle pour créer une pile de ressources OCI.
  5. Plan : Génère un plan décrivant les actions à effectuer.
  6. Appliquer : provisionne les ressources en fonction du plan.
  7. Détruire : dé provisionne les ressources lorsqu'elles ne sont plus nécessaires.

Pour déployer un cluster OKE à l'aide du nouveau module à partir d'OCI Resource Manager (ORM), commencez par télécharger le module avancé pour ORM : oke_advanced_module_orm.zip. Cette version est préconfigurée pour ORM, avec des variables définies sur des espaces réservés génériques tels que REPLACE_WITH_YOUR_OWN_VARIABLE_VALUE.

Tâche 2.1 : Configuration de la source

Mettez à jour variables.tf avec les détails propres à votre environnement, tels que la région, les CIDR de mise en réseau et les indicateurs pour contrôler la création de ressources (cluster VCN, OKE, pool de noeuds, bastion).

Le script bash suivant crée le fichier ZIP de sources de ressources ORM.

Vérifiez le répertoire source (~/oke_advanced_module_orm) pour vous assurer qu'un fichier nommé stackconfig.zip contient toutes les définitions de ressource terraform.

Tâche 2.2 : créer une pile OCI Resource Manager

Utilisez l'interface de ligne de commande OCI pour créer une pile ORM. Le script ci-dessous simplifie le processus :

Script Bash : create_new_oke_stack.sh.

	#!/bin/bash
	
	# Load environment variables (e.g., COMPARTMENT_ID, STACK_NAME, etc.)
	source "./env-vars"

	# Create the Oracle Resource Manager stack and capture the OCID
	stack_output=$(oci resource-manager stack create \
	--compartment-id "$COMPARTMENT_ID" --display-name "$STACK_NAME" \
	--description "$STACK_DESCRIPTION" --config-source "$CONFIG_SOURCE")

	# Extract the OCID of the newly created stack and display it
	STACK_OCID=$(echo "$stack_output" | jq -r '.data.id')

	echo "Stack OCID: $STACK_OCID"

Tâche 2.3 : exécuter le travail de plan de pile

Exécutez le travail Plan pour vérifier les modifications avant de les appliquer. Cette simulation assure la transparence des modifications d'infrastructure.

Script Bash : create_oke_stack_plan_job.sh

	#!/bin/bash

	# Load environment variables (e.g., STACK_OCID)
	source "./env-vars"

	# Create a plan job for the specified stack
	plan_job_output=$(oci resource-manager job create-plan-job \
		--stack-id "$STACK_OCID")

	# Extract the OCID of the plan job and check for errors
	PLAN_JOB_OCID=$(echo "$plan_job_output" | jq -r '.data.id')
	if [[ -z "$PLAN_JOB_OCID" ]]; then
		echo "Error: Failed to retrieve plan job OCID." >&2
		exit 1
	fi

	echo "Plan job OCID: $PLAN_JOB_OCID"

Tâche 2.4 : Créer un travail de candidature

Provisionnez le cluster OKE et les ressources associées, telles que le pool de noeuds, à l'aide du travail Apply.

Script Bash : create_oke_stack_apply_job.sh

	#!/bin/bash

	# Load environment variables (e.g., STACK_OCID, EXEC_PLAN_STRATEGY)
	source "./env-vars"

	# Create an apply job for the specified stack
	apply_job_output=$(oci resource-manager job create-apply-job \
		--stack-id "$STACK_OCID" \
		--execution-plan-strategy "$EXEC_PLAN_STRATEGY")

	# Extract the OCID of the apply job and check for errors
	APPLY_JOB_OCID=$(echo "$apply_job_output" | jq -r '.data.id')
	if [[ -z "$APPLY_JOB_OCID" ]]; then
		echo "Error: Failed to retrieve apply job OCID." >&2
		exit 1
	fi

	echo "Apply job OCID: $APPLY_JOB_OCID"

Tâche 2.5 : exécuter le travail de destruction

Nettoyez les ressources en exécutant le travail Destroy lorsque l'environnement n'est plus nécessaire.

Script Bash : create_oke_stack_destroy_job.sh

	#!/bin/bash

	# Load environment variables (e.g., STACK_OCID, EXEC_PLAN_STRATEGY)
	source "./env-vars"

	# Create an  jotroy for the specified stack
	apply_job_output=$(oci resource-manager job create-destroy-job \
		--stack-id "$STACK_OCID"  \
		--execution-plan-strategy "$EXEC_PLAN_STRATEGY")

	# Extract the OCID of the destroy job and check for errors
	DESTROY_JOB_OCID=$(echo "$apply_job_output" | jq -r '.data.id')
	if [[ -z "$DESTROY_JOB_OCID" ]]; then
		echo "Error: Failed to retrieve destroy job OCID." >&2
		exit 1
	fi

	echo "Apply job OCID: $DESTROY_JOB_OCID"

Automatisation d'OKE avec Jenkins et OCI Resource Manager

Nous avons créé un pipeline Jenkins pour automatiser le processus de provisionnement de bout en bout (tâches 2.1 à 2.4). Le pipeline exécute des scripts bash à l'aide de l'interface de ligne de commande OCI pour interagir avec ORM.

L'image ci-dessous illustre l'automatisation one-click pour les quatre premières tâches. L'étape destroy n'est pas incluse pour plus de simplicité.

OKEJenkinsPipeline

Le pipeline inclut la configuration source, la création de pile ORM, la génération de plan, le provisionnement des ressources et le déprovisionnement facultatif des ressources.

Etapes suivantes:

L'utilisation de Terraform pour le provisionnement OKE garantit la cohérence, l'automatisation et l'évolutivité. Les conceptions modulaires, combinées à OCI Resource Manager et aux pipelines d'intégration continue et de déploiement continu, simplifient et facilitent la maintenance des déploiements. Dans le prochain tutoriel, nous aborderons les meilleures pratiques en matière de surveillance, de sécurité et de préparation à la production. En nous appuyant sur ces bases, nous étendrons les modules à Oracle AIOps, créerons un modèle OKE de bout en bout pour les applications d'IA et démontrerons comment les analyses de journalisation avec l'observabilité basée sur l'IA peuvent détecter les anomalies et renforcer la sécurité de la plate-forme de conteneur.

Accusés de réception

Ressources de formation supplémentaires

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

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