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

Présentation

Il s'agit du deuxième tutoriel de notre série d'automatisation d'Oracle Cloud Infrastructure Kubernetes Engine (OKE), qui s'appuie sur les concepts fondamentaux du premier, Créer une grappe 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 l'automatisation avancée et la conception modulaire pour le provisionnement d'environnements évolutifs, résilients et hautement personnalisables sur Oracle Cloud Infrastructure (OCI).

Conçu pour les ingénieurs et les clients d'Oracle, ce guide vous permet de transformer une configuration Terraform de base en un module structuré et réutilisable pouvant être adapté à toute taille de déploiement. En tirant parti des principes Infrastructure-code (IaC) avec Terraform (version de communauté), combinés à Jenkins et à Oracle Command Line Interface (CLI), nous fournissons une solution de provisionnement single-click pour les grappes OKE, leurs configurations et les tests automatisés.

Ce tutoriel porte 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 grappes OKE et les hôtes bastion, avec contrôle 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. Groupes de noeuds avancés : Optimisez l'utilisation et les coûts des ressources avec des formes spécialisées, des images OKE compatibles et des étiquettes pour le positionnement intelligent de la charge de travail.
  4. Intégration transparente de l'intégration et du développement en continu : 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 à niveaux pour créer une base sécurisée et évolutive. Il sépare le plan de contrôle, les noeuds de travail et le trafic de l'équilibreur de charge, ce qui assure la flexibilité des charges de travail d'entreprise de tous niveaux. Nous allons démontrer comment automatiser entièrement le provisionnement de cet environnement, y compris le réseau, les grappes et les groupes de noeuds, tout en fournissant les outils permettant de personnaliser et d'étendre la solution à vos besoins.

Ce tutoriel explique les principes de Kubernetes, de réseau et IaC, ainsi que les connaissances pratiques 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, hautement performant et évolutif sur OCI, avec la flexibilité nécessaire pour l'adapter à vos exigences particulières.

Aperçu 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 des 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 de niveau entreprise nécessite une planification minutieuse et l'utilisation d'outils Infrastructure as Code (IaC) tels que Terraform.

La modularisation et l'automatisation sont essentielles pour OKE pour assurer 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 les charges de travail critiques de manière uniforme, réduire les erreurs manuelles et accélérer les délais de mise sur le marché.

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

Architecture OKE

Pour un exemple détaillé de l'architecture, consultez la Documentation d'Oracle.

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

Éléments de conception clés
Cette solution modulaire s'appuie sur une architecture réseau hiérarchisée qui fournit une base sécurisée et évolutive pour les charges de travail d'entreprise sur OKE :

Création d'une automatisation Terraform modulaire pour OKE

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

Processus de transformation : Module plat à module structuré

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

  1. Restructuration du répertoire : Création de modules enfants (vcn, oke, bastion) et organisation des ressources dans leurs dossiers respectifs.
  2. Application des principes clés :
    • Structure et logique : Encapsulez les ressources dans des répertoires autonomes (par exemple, modules/vcn, modules/oke, modules/bastion) et fractionnez le code monolithique en main.tf, variables.tf et outputs.tf pour plus de lisibilité et de facilité de maintenance.
    • Entrées/Sorties et contrôle des versions : Définissez les entrées dans variables.tf, exposez les sorties dans outputs.tf et utilisez la contrainte version de contrôle des versions du module Terraform dans source pour un flux de données transparent et une compatibilité transparente.
    • Orchestration : Gérez la logique conditionnelle telle que count au niveau du module racine, en gardant les modules enfants centrés sur leurs ressources.

Structure du répertoire : plat par rapport à 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, hôte bastion) se trouve dans son propre répertoire de module. Le module racine orchestre les dépendances et la configuration de niveau supérieur.

Structure de module avancée

Exemples de modules

Pourquoi des modules?

Orchestration des 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é conditionnellement en fonction d'indicateurs de configuration (is_vcn_created, is_oke_created, is_bastion_created), offrant ainsi une flexibilité de 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 le main.tf complet.

Flux d'orchestration :

  1. Module VCN (modules/vcn) :
    • Provisionne le réseau en nuage virtuel (VCN) et les sous-réseaux connexes (par exemple, sous-réseaux privés pour l'API Kubernetes et les noeuds de travail, sous-réseaux publics pour les équilibreurs de charge et l'hôte bastion).
    • Contrôlé par is_vcn_created. Si cette option est activée, elle crée le VCN; sinon, elle suppose un VCN existant (vous devez fournir l'OCID de son sous-réseau utilisé).
    • Exemple d'extrait 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 la grappe OCI Kubernetes Engine (OKE), y compris le plan de contrôle et les groupes de noeuds gérés facultatifs.
    • Dépend du module VCN pour les ID sous-réseau. Appelé uniquement si is_oke_created et is_vcn_created sont vrais.
    • Exemple d'extrait 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 d'hôte bastion (modules/bastion) :
    • Crée un hôte bastion pour l'accès SSH sécurisé aux ressources privées.
    • Dépend du module VCN pour l'ID sous-réseau public. Appelé uniquement si is_bastion_created et is_vcn_created sont vrais.
    • Exemple d'extrait 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...  
   }

      Notes clés :

    • 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épendances claire.
    • Logique de configuration : Les mappages de paramètres simplifiés (par exemple, node_pool_param, bastion_params) simplifient la configuration et la lisibilité.
    • Contrôle 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 assure 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 des nouvelles fonctions et services.

Options d'automatisation

Plusieurs outils peuvent automatiser les déploiements OKE, notamment l'interface de ligne de commande Terraform, le gestionnaire de ressources OCI (ORM), l'interface de ligne de commande OCI, les modules Ansible OCI et Helm. Toutefois, ce guide se concentre sur les deux approches d'infrastructure-code (IaC) les plus importantes dans Oracle Cloud Infrastructure (OCI) : Interface de ligne de commande Terraform et Gestionnaire de ressources OCI.

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

Examinons chaque option en détail.

Option 1 : Déployer des 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 complet sur votre environnement local. Il convient le mieux aux développeurs individuels ou aux petites équipes qui peuvent gérer le fichier d'état et collaborer efficacement à l'aide d'un serveur dorsal partagé. Sa portabilité vous permet de l'exécuter à partir de n'importe quel ordinateur : local, machine virtuelle, conteneur, OCI CloudShell ou exécutants d'intégration et de développement en continu tels que Jenkins. Cependant, cette flexibilité comporte des responsabilités, telles que la gestion des fichiers d'état et la garantie de configurations locales cohérentes entre les membres de l'équipe.

Pour commencer, téléchargez et décompressez l'ensemble de code source de l'interface de ligne de commande Terraform dans votre répertoire de travail Terraform. Cet ensemble comprend main.tf, un exemple terraform.tfvars et des configurations de module détaillées : Télécharger 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 du réseau à la configuration de la grappe OKE, des groupes de noeuds et de l'hôte bastion. Voici les étapes détaillées pour provisionner et 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 de ressources :

Tâche 1.2 : Configuration du réseau

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

Tâche 1.3 : Configuration de la grappe OKE

Tâche 1.4 : Configuration du groupe de noeuds

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

Tâche 1.6 : Exécuter des commandes Terraform

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

	terraform init
	terraform plan
	terraform apply

Une fois terraform apply terminé, votre grappe OKE sera provisionnée avec :

Tâche 1.7 : Vérification

  1. Naviguez jusqu'à la console OCI pour vérifier la configuration de la grappe.
  2. Exécutez terraform destroy pour nettoyer les ressources lorsque vous avez terminé.

Automatisation du déploiement OKE avec le pipeline d'intégration et de développement en 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éer une grappe Oracle Cloud Infrastructure Kubernetes Engine à l'aide de Terraform, utilise des scripts bash pour orchestrer le processus. Ce flux de travail peut être consolidé en pipeline Jenkins pour une exécution automatisée.

Option 2 : Automatisation d'OKE avec le gestionnaire de ressources OCI

Le gestionnaire de ressources OCI est le choix idéal lorsque vous avez besoin d'une solution en nuage 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 dans OCI, en stockant le fichier d'état en toute sécurité et en évitant les conflits. Cela élimine le besoin de configuration locale ou de gestion d'un serveur dorsal partagé. De plus, l'intégration étroite d'ORM avec Oracle Cloud lui permet de tirer parti des fonctions OCI natives telles que Identity and Access Management (IAM), améliorant ainsi la sécurité et le contrôle.

Dans ce tutoriel, nous combinons le gestionnaire de ressources OCI (ORM) à l'interface de ligne de commande OCI, Bash, et les intégrons dans des pipelines d'intégration et de développement en continu Jenkins, offrant un flux d'automatisation one-click complet avec des capacités DevOps supplémentaires telles que la détection de dérive, la gestion sécurisée de l'état et la collaboration d'équipe avec le contrôle des versions pour assurer la compatibilité.

Flux du gestionnaire de ressources OCI
Le diagramme suivant présente le flux de travail ORM, composé de sept étapes :
Flux de travail ORM

  1. Configuration source : Définit l'origine de la configuration IaC (par exemple, Stockage d'objets OCI, GitHub, fichier zip).
  2. Modèle Terraform : L'infrastructure est définie à l'aide de Terraform.
  3. Gestionnaire de ressources OCI : 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 : Permet de provisionner les ressources en fonction du plan.
  7. Détruire : Déprovisionne les ressources lorsqu'elles ne sont plus nécessaires.

Pour déployer une grappe OKE à l'aide du nouveau module du gestionnaire de ressources OCI (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 réglées à des paramètres fictifs 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 blocs CIDR de réseau et les indicateurs pour contrôler la création de ressources (VCN, grappe OKE, groupe de noeuds, hôte bastion).

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

Vérifiez votre 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 du gestionnaire de ressources OCI

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 la tâche de plan de pile

Exécutez la tâche Plan pour vérifier les modifications avant de les appliquer. Cette exécution à sec assure la transparence des changements 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 une tâche de candidature

Provisionnez la grappe OKE et les ressources associées, telles que le groupe de noeuds, à l'aide de la tâche 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 la tâche Destroy

Nettoyez les ressources en exécutant la tâche 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 le gestionnaire de ressources OCI

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 montre l'automatisation one-click pour les quatre premières tâches; l'étape destroy n'est pas incluse pour simplifier.

OKEJenkinsPipeline

Le pipeline comprend 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.

Étapes suivantes :

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

Remerciements

Ressources d'apprentissage supplémentaires

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

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