Partie-2 / blogs / perficient

Dans Partie 1nous avons appris l’importance de la kubeone. Maintenant, explorez-vous sur une partie de démonstration de cette session pratique se concentrera sur la création d’un cluster de Kubernetes à haute disponibilité sur AWS à l’aide de Kubeone

Configuration de la kubeone

1. Télécharger Kubeone

Créez d’abord l’instance EC2 avec n’importe quel type en tant qu’adaptation, puis téléchargez Kubeone à partir du script ci-dessous. Les commandes ci-dessous seront utilisées pour télécharger Kubeone

Mise à jour Sudo apt-get

sudo apt-get -y installer unzip

curl -sfl https://get.kubeone.io | shot

Le script ci-dessus télécharge la dernière version de Kubeone de GitHub et le déballe dans le répertoire / usr / local / bin.

2. Télécharger Terraform

Nous utiliserons Terraform pour gérer l’infrastructure du plan de contrôle, pour cela, nous devons l’installer. Nous utiliserons les scripts suivants pour télécharger le terraform

Vous trouverez ci-dessous le lien de documentation officiel pour installer Terraform:

https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli

Il s’agit de la signature GPG du Hashicorp et il installera le référentiel de packages Debian de Hashicorp.

Sudo Apt-Get Update && sudo apt-get install -y gnupg logiciel-properties-common

Installez maintenant le hashicorp Clé GPG:

wget -o- https://apt.releases.hashicorp.com/gpg | \

GPG –Dearmor | \

sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg> / dev / nul

Vérifiez l’empreinte digitale de la clé:

GPG –No-Default-Keyring \

–Keyring /usr/share/keyrings/hashicorp-archive-keyring.gpg \

-empreinte digitale

Ajoutez le référentiel officiel de Hashicorp dans le système:

Echo «Deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] \

https://apt.releases.hashicorp.com $ (lsb_release -cs) Main ”| \

sudo tee /etc/apt/sources.list.d/hashicorp.list

Téléchargez les informations du package à partir de Hashicorp.

Mise à jour Sudo Apt

Installez Terraform à partir du nouveau référentiel.

sudo apt-get install terraform -y

3. Configuration de l’environnement

Télécharger le CLI AWS

sudo apt install unzip -y

Curl «https://awscli.amazonaws.com/awscli-exe-inux-x86_64.zip» -o «awscliv2.zip»

unzip awscliv2.zip

sudo ./aws/install

Kubeone et Terraform ont besoin des informations d’identification du fournisseur de cloud exportées sous forme de variables d’environnement.

Créer un utilisateur IAM

Nous avons besoin du compte IAM avec les autorisations appropriées pour Terraform pour créer l’infrastructure et pour le contrôleur de machine pour créer des nœuds de travailleurs.

Cliquez sur «Utilisateurs» et «Créer un utilisateur»

Une fois que l’utilisateur a créé, alors «stratégie d’attachement»

Cliquez sur la création de «clé d’accès et de clé secrète»

Nous utiliserons «AWS Configurer» pour configurer les deux touches

AWS Configure

4. Création de l’infrastructure

Créer une paire de clés sur le serveur

SSH-Keygen -T RSA -B 4096 Maintenant, déplacez le répertoire avec le exemple CONFIGS TERRAFORM qui ont été créés lors de l’installation de Kubeone.CD kubeone_1.9.1_linux_amd64 / Exemples / terraform / aws

Avant d’utiliser le Terraform, nous initialiserons la structure du répertoire et téléchargerons les plugins requis. Utilisez la commande init ci-dessous

Terraform init

Également dans le même répertoire, créez le fichier IE terraform.tfvars, il contiendra des variables Terraform pour personnaliser le processus de création d’infrastructure.

vim terraform.tfvars

Ajoutez maintenant les deux variables ci-dessous

cluster_name = « kubeone-cluster »

ssh_public_key_file = “~ / .ssh / id_rsa.pub”

La variable Cluster_Name est utilisée comme préfixe pour les ressources cloud. Le SSH_PUBLIC_KEY_FILE est le chemin vers une clé publique SSH qui sera déployée sur les cas. Kubeone sera connecté à des instances sur SSH pour l’approvisionnement et la configuration. Si vous souhaitez générer, exécutez le ssh-keygen.

Maintenant, exécutez Terraform Plan Command pour voir les modifications effectuées.

plan de terre

Exécutez maintenant la commande Terraform Appliquez et entrez «Oui»

Terraform s’applique

La commande ci-dessus créera toute l’infrastructure dont nous avions besoin pour commencer.

Enfin, nous devons enregistrer l’état Terraform dans un format que Kubeone peut lire pour obtenir des informations sur les ressources AWS. Cela aide à configurer le cluster et à créer des nœuds de travailleurs plus tard. Le format est déjà défini dans un fichier appelé output.tf, donc tout ce que vous avez à faire est d’exécuter la commande de sortie.

Terraform Sortie -json> tf.json

Cette commande crée un fichier nommé tf.json avec l’état Terraform au format JSON, que Kubeone peut lire. Une fois cela fait, nous sommes prêts à configurer notre cluster à l’étape suivante.

Étape 5. Provisioning du cluster

Maintenant que l’infrastructure est prête, nous pouvons utiliser Kubeone pour configurer un cluster Kubernetes.

La première étape consiste à créer un fichier de configuration Kubeone (kubeone.yaml). Ce fichier définira des détails comme la façon dont le cluster sera configuré et quelle version de Kubernetes à utiliser.

vim kubeone.yaml

Ajouter le code ci-dessous dans le fichier YAML ci-dessus

Apiversion: kubeone.k8c.io/v1beta2

genre: kubeonecluster

Versions:

Kubernetes: ‘1.30.0’

CloudProvider:

AWS: {}

Externe: vrai

Avant de continuer, choisissez la version Kubernetes que vous souhaitez utiliser et remplacez toutes les valeurs d’espace réservé par celles réelles.

Définissez maintenant la variable d’environnement, utilisez la commande d’exportation pour cela

Export AWS_ACCESS_KEY_ID = $ (AWS Configurez Get AWS_ACCESS_KEY_ID)

Export AWS_SECRET_ACCESS_KEY = $ (AWS Configurez Get AWS_SECRET_ACCESS_KEY)

Maintenant, exécutez à nouveau la commande ci-dessous

kubeone appliquer -m kubeone.yaml -t tf.json

Si nous obtenons l’erreur ci-dessous

Maintenant, exécutez ces commandes ci-dessous pour démarrer des agents

Démarrer l’agent frais

# Démarrer correctement l’agent SSH

évaluer «$ (ssh-agent)»

# Vérifiez les variables d’environnement

echo $ ssh_auth_sock

echo $ ssh_agent_pid

Ajouter les touches SSH

# Ajoutez votre clé privée

SSH-ADD ~ / .SSH / ID_RSA

# Vérifiez que les clés sont ajoutées

SSH-ADD -L

Définissez les autorisations correctes:

# Correction des autorisations du répertoire SSH

Chmod 700 ~ / .ssh

chmod 600 ~ / .ssh / id_rsa

chmod 644 ~ / .ssh / id_rsa.pub

Exécutez à nouveau la commande Appliquer
kubeone appliquer -m kubeone.yaml -t tf.json

Cela créera un cluster.

6. Installer Kubectl

Installons le kubectl:

Curl -LO « https://dl.k8s.io/release/$(curl -l -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl »

curl -lo “https://dl.k8s.io/release/$(curl -l -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl.sha256″

echo «$ (cat kubectl.sha256) kubectl» | sha256sum –Check

Sudo install -o root -g root -m 0755 kubectl / usr / local / bin / kubectl

chmod + x kubectl

mkdir -p ~ / .local / bin

mv ./Kubectl ~ / .local / bin / kubectl

7. Configuration de l’accès au cluster

Kubeone télécharge automatiquement le fichier kubeconfig pour votre cluster, nommé -kubeconfig (où est du fichier terraform.tfvars). Vous pouvez utiliser ce fichier avec Kubectl comme ceci:

kubectl –kubeconfig = -kubeconfig

kubectl get nœuds –kubeconfig = kubeone-cluster-kubeconfig

Copiez maintenant la configuration dans le dossier .kube

CP Kubeone-Cluster-KubeConfig ~ / .Kube / Config

Essayez maintenant sans –kubeconfig

Kubectl obtient des nœuds

Créons un pod «nginx» à l’aide de scripts ci-dessous

Kubectl run nginx –image = nginx

Kubectl obtient des pods

Arrêter le cluster

L’objectif de non-parcours est de supprimer le cluster et de libérer des ressources cloud. Utilisez-le uniquement si vous n’avez plus besoin du cluster. Si vous souhaitez annuler cela, vous pouvez utiliser la commande de réinitialisation ci-dessous.

Kubeone réinitialisation –Manifest kubeone.yaml -t tf.json

Suppression des infrastructures à l’aide de Terraform

Si vous utilisez Terraform, vous pouvez supprimer toutes les ressources avec la commande Detrère. Terraform énumra ce qui sera supprimé et vous demandera de confirmer en tapant «oui». Si votre cluster est sur GCP, vous devez supprimer manuellement les routes créées par Kube-Controller-Manager dans la console Cloud avant d’exécuter TerraForm détruire.

Terraform détruise

Supprimez tous les serveurs et l’utilisateur IAM à la fin.

Conclusion:

Kubeone est un choix solide et fiable pour automatiser la gestion des cluster Kubernetes, en particulier pour les utilisateurs qui ont besoin d’une grande disponibilité et d’une prise en charge multi-cloud ou hybride. Il est particulièrement bien adapté aux organisations à la recherche d’une solution simple mais puissante pour gérer Kubernetes à grande échelle sans les frais généraux de plateformes de gestion plus complexes. Cependant, il pourrait ne pas avoir un écosystème ou une base d’utilisateurs aussi large que certaines des alternatives les plus connues.