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.
Source link