Version imprimable multipages. Cliquer ici pour imprimer.

Outils d'installation

1: Installer et configurer kubectl
2: Installer Minikube

1 - Installer et configurer kubectl

Installation et configuration de kubectl

L'outil en ligne de commande de kubernetes, kubectl, vous permet d'exécuter des commandes dans les clusters Kubernetes. Vous pouvez utiliser kubectl pour déployer des applications, inspecter et gérer les ressources du cluster et consulter les logs. Pour une liste complète des opérations kubectl, voir Aperçu de kubectl.

Pré-requis

Vous devez utiliser une version de kubectl qui différe seulement d'une version mineure de la version de votre cluster. Par exemple, un client v1.2 doit fonctionner avec un master v1.1, v1.2 et v1.3. L'utilisation de la dernière version de kubectl permet d'éviter des problèmes imprévus.

Installer kubectl sur Linux

Installer le binaire de kubectl avec curl sur Linux

Téléchargez la dernière release avec la commande :
```
curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl
```
Pour télécharger une version spécifique, remplacez $(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt) avec la version spécifique.

Par exemple, pour télécharger la version v1.25.0 sur Linux, tapez :
```
curl -LO https://storage.googleapis.com/kubernetes-release/release/v1.25.0/bin/linux/amd64/kubectl
```
Rendez le binaire kubectl exécutable.
```
chmod +x ./kubectl
```

Déplacez le binaire dans votre PATH.

sudo mv ./kubectl /usr/local/bin/kubectl

Testez pour vous assurer que la version que vous avez installée est à jour:
```
kubectl version --client
```

Installation à l'aide des gestionnaires des paquets natifs

Ubuntu, Debian or HypriotOS
CentOS, RHEL or Fedora


sudo apt-get update && sudo apt-get install -y apt-transport-https
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee -a /etc/apt/sources.list.d/kubernetes.list
sudo apt-get update
sudo apt-get install -y kubectl

sudo cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
EOF
sudo yum install -y kubectl

Installation avec des gestionnaires de paquets alternatifs

Snap
Homebrew

Si vous êtes sur Ubuntu ou une autre distribution Linux qui supporte le gestionnaire de paquets snap, kubectl est disponible comme application snap.

snap install kubectl --classic

kubectl version --client

Si vous êtes sur Linux et que vous utiliser Homebrew comme gestionnaire de paquets, kubectl est disponible. installation

brew install kubectl

kubectl version --client

Installer kubectl sur macOS

Installer le binaire kubectl avec curl sur macOS

Téléchargez la dernière version:

curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/darwin/amd64/kubectl

Pour télécharger une version spécifique, remplacez $(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt) avec la version spécifique.

Par exemple, pour télécharger la version v1.25.0 sur macOS, tapez :

curl -LO https://storage.googleapis.com/kubernetes-release/release/v1.25.0/bin/darwin/amd64/kubectl

Rendez le binaire kubectl exécutable.
```
chmod +x ./kubectl
```

Déplacez le binaire dans votre PATH.

sudo mv ./kubectl /usr/local/bin/kubectl

Testez pour vous assurer que la version que vous avez installée est à jour:
```
kubectl version --client
```

Installer avec Homebrew sur macOS

Si vous êtes sur MacOS et que vous utilisez le gestionnaire de paquets Homebrew, vous pouvez installer kubectl avec Homebrew.

Exécutez la commande d'installation:

brew install kubectl

brew install kubernetes-cli

Testez pour vous assurer que la version que vous avez installée est à jour:
```
kubectl version --client
```

Installer avec Macports sur macOS

Si vous êtes sur MacOS et que vous utilisez le gestionnaire de paquets Macports, vous pouvez installer kubectl avec Macports.

Exécuter la commande d'installation:

sudo port selfupdate
sudo port install kubectl

Testez pour vous assurer que la version que vous avez installée est à jour:
```
kubectl version --client
```

Installer kubectl sur Windows

Installer le binaire kubectl avec curl sur Windows

Téléchargez la dernière version v1.25.0 depuis ce lien.

Ou si vous avez curl installé, utilisez cette commande:
```
curl -LO https://storage.googleapis.com/kubernetes-release/release/v1.25.0/bin/windows/amd64/kubectl.exe
```
Pour connaître la dernière version stable (par exemple, en scripting), jetez un coup d'oeil à https://storage.googleapis.com/kubernetes-release/release/stable.txt.
Ajoutez le binaire dans votre PATH.
Testez pour vous assurer que la version que vous avez installée est à jour:
```
kubectl version --client
```

Note: Docker Desktop pour Windows ajoute sa propre version de kubectl au $PATH. Si vous avez déjà installé Docker Desktop, vous devrez peut-être placer votre entrée PATH avant celle ajoutée par le programme d'installation de Docker Desktop ou supprimer le kubectl de Docker Desktop.

Installer avec Powershell de PSGallery

Si vous êtes sous Windows et que vous utilisez le gestionnaire de paquets Powershell Gallery , vous pouvez installer et mettre à jour kubectl avec Powershell.

Exécutez les commandes d'installation (spécifier le DownloadLocation):
```
Install-Script -Name install-kubectl -Scope CurrentUser -Force
install-kubectl.ps1 [-DownloadLocation <path>]
```
Note: Si vous ne spécifiez pas un DownloadLocation, kubectl sera installé dans le répertoire temp de l'utilisateur.

Le programme d'installation creé $HOME/.kube qui est suivie par la création d'un fichier de configuration
Testez pour vous assurer que la version que vous avez installée est à jour:
```
kubectl version --client
```
Note: La mise à jour de l'installation s'effectue en réexécutant les deux commandes listées à l'étape 1.

Installer sur Windows avec Chocolatey ou Scoop

Pour installer kubectl sur Windows, vous pouvez utiliser le gestionnaire de paquets Chocolatey ou l'installateur en ligne de commande Scoop.

choco
scoop

choco install kubernetes-cli

scoop install kubectl

2. Testez pour vous assurer que la version que vous avez installée est à jour:

```
kubectl version --client
```

Accédez à votre répertoire personnel:
```
cd %USERPROFILE%
```
Créez le répertoire .kube:
```
mkdir .kube
```
Allez dans le répertoire .kube que vous venez de créer:
```
cd .kube
```
Configurez kubectl pour utiliser un remote cluster Kubernetes:
```
New-Item config -type file
```
Note: Editez le fichier de configuration avec un éditeur de texte de votre choix, tel que Notepad.

Télécharger en tant qu'élément du SDK Google Cloud

Vous pouvez installer kubectl en tant qu'élément du SDK Google Cloud.

Installer Google Cloud SDK.
Exécutez la commande d'installation kubectl:
```
gcloud components install kubectl
```
Testez pour vous assurer que la version que vous avez installée est à jour:
```
kubectl version --client
```

Vérification de la configuration de kubectl

Pour permettre à kubectl de trouver et d'accéder à un cluster Kubernetes, il lui faut un fichier kubeconfig, qui est créé automatiquement lorsque vous créez un cluster avec kube-up.sh ou en déployant un cluster Minikube avec succès. Par défaut, la configuration de kubectl est située sous ~/.kube/config.

Vérifiez que kubectl est correctement configuré en obtenant l'état du cluster:

kubectl cluster-info

Si vous voyez une réponse avec une URL, kubectl est correctement configuré pour accéder à votre cluster.

Si vous voyez un message similaire à celui qui suit, kubectl n'est pas configuré correctement ou n'est pas capable de se connecter à un cluster Kubernetes.

The connection to the server <server-name:port> was refused - did you specify the right host or port?

Si par exemple, vous avez l'intention d'exécuter un cluster Kubernetes sur votre machine (localement), vous aurez besoin d'un outil comme Minikube pour être installé en premier et exécuter à nouveau les commandes décrites ci-dessus.

Si kubectl cluster-info retourne la réponse en url mais que vous ne pouvez pas accéder à votre cluster, vous pouvez vérifier s'il est configuré correctement, en utilisant:

kubectl cluster-info dump

Configurations kubectl optionnelles

Activation de l'auto-complétion de shell

kubectl fournit un support d'auto-complétion pour Bash et Zsh, ce qui peut vous éviter beaucoup de temps de saisie.

Vous trouverez ci-dessous les étapes à suivre pour configurer l'auto-complétion pour Bash (y compris la différence entre Linux et MacOS) et Zsh.

Introduction

Le script de complétion kubectl pour Bash peut être généré avec la commande kubectl completion bash. Sourcer le script de completion dans votre shell permet l'auto-complétion de kubectl.

En revanche, le script de complétion dépend de bash-completion, ce qui implique que vous devez d'abord installer ce logiciel (vous pouvez tester si vous avez déjà installé bash-completion en utilisant type _init_completion).

Installer bash-completion

bash-completion est fourni par plusieurs gestionnaires de paquets (voir ici). Vous pouvez l'installer avec apt-get install bash-completion or yum install bash-completion, etc.

Les commandes ci-dessus créent /usr/share/bash-completion/bash_completion, qui est le script principal de bash-completion. En fonction de votre gestionnaire de paquets, vous devez manuellement sourcer ce fichier dans votre ~/.bashrc.

Il vous suffit de recharger votre shell et de lancer type _init_completion. Si la commande réussit, vous êtes déjà configuré, sinon ajoutez le suivant à votre fichier `~/.bashrc' :

source /usr/share/bash-completion/bash_completion

Rechargez votre shell et vérifiez que bash-completion est correctement installé en tapant type _init_completion.

Activer l'auto-complétion de kubectl

Vous devez maintenant vérifier que le script de completion de kubectl est bien sourcé dans toutes vos sessions shell. Il y a deux façons de le faire:

Sourcer le script de completion dans votre fichier ~/.bashrc:
```
echo 'source <(kubectl completion bash)' >>~/.bashrc
```
Ajoutez le script de complétion dans le répertoire /etc/bash_completion.d:
```
kubectl completion bash >/etc/bash_completion.d/kubectl
```
Si vous avez un alias pour kubectl, vous pouvez étendre la completion de votre shell pour fonctionner avec cet alias:
```
echo 'alias k=kubectl' >>~/.bashrc
echo 'complete -o default -F __start_kubectl k' >>~/.bashrc
```

Note: bash-completion source tous les scripts de completion dans /etc/bash_completion.d.

Les deux approches sont équivalentes. Après avoir rechargé votre shell, l'auto-complétion de kubectl devrait fonctionner.

Introduction

Le script de complétion kubectl pour Bash peut être généré avec la commande kubectl completion bash. Sourcer le script de completion dans votre shell permet l'auto-complétion de kubectl.

En revanche, le script de complétion dépend de bash-completion, ce qui implique que vous devez d'abord installer ce logiciel.

Attention: macOS inclut Bash 3.2 par défaut. Le script de complétion kubectl nécessite Bash 4.1+ et ne fonctionne pas avec Bash 3.2. Une des solutions possibles est d'installer une version plus récente de Bash sous macOS (voir instructions ici). Les instructions ci-dessous ne fonctionnent que si vous utilisez Bash 4.1+.

Installer bash-completion

Note: Comme mentionné, ces instructions supposent que vous utilisez Bash 4.1+, ce qui signifie que vous installerez bash-completion v2 (contrairement à Bash 3.2 et bash-completion v1, auquel cas la complétion pour kubectl ne fonctionnera pas).

Vous pouvez tester si vous avez déjà installé bash-completion en utilisant type _init_completion. Si il n'est pas installé, vous pouvez installer bash-completion avec Homebrew:

brew install bash-completion@2

Comme indiqué dans la sortie de brew install (section "Caveats"), ajoutez les lignes suivantes à votre fichier ~/.bashrc ou ~/.bash_profile :

export BASH_COMPLETION_COMPAT_DIR="/usr/local/etc/bash_completion.d"
[[ -r "/usr/local/etc/profile.d/bash_completion.sh" ]] && . "/usr/local/etc/profile.d/bash_completion.sh"

Rechargez votre shell et vérifiez que bash-completion v2 est correctement installé avec type _init_completion.

Activer l'auto-complétion de kubectl

Si vous n'avez pas installé via Homebrew, vous devez maintenant vous assurer que le script de complétion kubectl est bien sourcé dans toutes vos sessions shell comme suit:

Sourcer le script de completion dans votre fichier ~/.bashrc:
```
echo 'source <(kubectl completion bash)' >>~/.bashrc
```
Ajoutez le script de complétion dans le répertoire /usr/local/etc/bash_completion.d:
```
kubectl completion bash >/usr/local/etc/bash_completion.d/kubectl
```
Si vous avez un alias pour kubectl, vous pouvez étendre la completion de votre shell pour fonctionner avec cet alias:
```
echo 'alias k=kubectl' >>~/.bashrc
echo 'complete -o default -F __start_kubectl k' >>~/.bashrc
```

Si vous avez installé kubectl avec Homebrew (comme expliqué ici), alors le script de complétion a été automatiquement installé dans /usr/local/etc/bash_completion.d/kubectl. Dans ce cas, vous n'avez rien à faire.

Note: L'installation Homebrew de bash-complétion v2 source tous les fichiers du répertoire BASH_COMPLETION_COMPAT_DIR, c'est pourquoi les deux dernières méthodes fonctionnent.

Après avoir rechargé votre shell, l'auto-complétion de kubectl devrait fonctionner.

Le script de complétion de kubectl pour Zsh peut être généré avec la commande kubectl completion zsh. Sourcer le script de completion dans votre shell permet l'auto-complétion de kubectl.

Pour faire ainsi dans toutes vos sessions shell, ajoutez ce qui suit à votre fichier ~/.zshrc:

source <(kubectl completion zsh)

Si vous avez un alias pour kubectl, vous pouvez étendre la completion de votre shell pour fonctionner avec cet alias:

echo 'alias k=kubectl' >>~/.zshrc
echo 'compdef __start_kubectl k' >>~/.zshrc

Après avoir rechargé votre shell, l'auto-complétion de kubectl devrait fonctionner.

Si vous rencontrez une erreur comme complete:13: command not found: compdef, alors ajoutez ce qui suit au début de votre fichier ~/.zshrc:

autoload -Uz compinit
compinit

A suivre

Installer Minikube
Voir les guides de démarrage pour plus d'informations sur la création de clusters.
Apprenez comment lancer et exposer votre application
Si vous avez besoin d'accéder à un cluster que vous n'avez pas créé, consultez Partager l'accès du Cluster.
Consulter les documents de référence de kubectl

2 - Installer Minikube

Cette page vous montre comment installer Minikube, qui est un outil qui fait tourner un cluster Kubernetes à un noeud unique dans une machine virtuelle sur votre machine.

Pré-requis

Pour vérifier si la virtualisation est prise en charge sur Linux, exécutez la commande suivante et vérifiez que la sortie n'est pas vide :

grep -E --color 'vmx|svm' /proc/cpuinfo

Pour vérifier si la virtualisation est prise en charge sur macOS, exécutez la commande suivante sur votre terminal.

sysctl -a | grep -E --color 'machdep.cpu.features|VMX'

Si vous trouvez VMX dans la sortie, la fonction VT-x est supportée sur votre OS.

Pour vérifier si la virtualisation est prise en charge sur Windows 8 et au-delà, exécutez la commande suivante sur votre terminal Windows ou à l'invite de commande.

systeminfo

Si vous obtenez la sortie suivant, la virtualisation est prise en charge sur Windows.

Hyper-V Requirements:     VM Monitor Mode Extensions: Yes
                          Virtualization Enabled In Firmware: Yes
                          Second Level Address Translation: Yes
                          Data Execution Prevention Available: Yes

Si vous voyez la sortie suivante, votre système a déjà un hyperviseur installé et vous pouvez ignorer l'étape suivante.

Configuration requise pour Hyper-V: un hyperviseur a été détecté. Les fonctionnalités requises pour Hyper-V ne seront pas affichées.

Installer Minikube

Installer kubectl

Installez kubectl en suivant les instructions de la section Installer et configurer kubectl.

Installer un hyperviseur

Si vous n'avez pas déjà un hyperviseur installé, installez-le maintenant pour votre système d'exploitation :

• KVM, qui utilise également QEMU

• VirtualBox

Minikube supporte également une option --vm-driver=none qui exécute les composants Kubernetes sur la machine hôte et pas dans une VM. L'utilisation de ce pilote nécessite Docker et un environnement Linux mais pas un hyperviseur.

Si vous utilisez le pilote none dans Debian ou un dérivé, utilisez les paquets .deb pour Docker plutôt que le package snap, qui ne fonctionne pas avec Minikube. Vous pouvez télécharger les packages .deb depuis Docker.

Avertissement: Le pilote VM none peut entraîner des problèmes de sécurité et de perte de données. Avant d'utiliser --driver=none, consultez cette documentation pour plus d'informations.

Minikube prend également en charge un vm-driver=podman similaire au pilote Docker. Podman est exécuté en tant que superutilisateur (utilisateur root), c'est le meilleur moyen de garantir que vos conteneurs ont un accès complet à toutes les fonctionnalités disponibles sur votre système.

Avertissement: Le pilote podman nécessite l’exécution des conteneurs en tant que root car les comptes d’utilisateurs normaux n’ont pas un accès complet à toutes les fonctionnalités du système d’exploitation que leurs conteneurs pourraient avoir besoin d’exécuter.

Installer Minikube à l'aide d'un package

Il existe des packages * expérimentaux * pour Minikube; vous pouvez trouver des packages Linux (AMD64) depuis la page releases de Minikube sur GitHub.

Utilisez l'outil de package de votre distribution Linux pour installer un package approprié.

Installez Minikube par téléchargement direct

Si vous n'installez pas via un package, vous pouvez télécharger un binaire autonome et l'utiliser.

curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64 \
  && chmod +x minikube

Voici un moyen simple d'ajouter l'exécutable Minikube à votre path :

sudo mkdir -p /usr/local/bin/
sudo install minikube /usr/local/bin/

Installer Minikube en utilisant Homebrew

Une autre alternative, vous pouvez installer Minikube en utilisant Linux [Homebrew] (https://docs.brew.sh/Homebrew-on-Linux) :

brew install minikube

Installer kubectl

Installez kubectl en suivant les instructions de la section Installer et configurer kubectl.

Installer un hyperviseur

Si vous n'avez pas encore installé d'hyperviseur, installez-en un maintenant :

• HyperKit

• VirtualBox

• VMware Fusion

Installer Minikube

La façon la plus simple d'installer Minikube sur macOS est d'utiliser Homebrew:

brew install minikube

Vous pouvez aussi l'installer sur macOS en téléchargeant un binaire statique :

curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-darwin-amd64 \
  && chmod +x minikube

Voici une façon simple d'ajouter l'exécutable de Minikube à votre path :

sudo mv minikube /usr/local/bin

Installer kubectl

Installez kubectl en suivant les instructions de la section Installer et configurer kubectl.

Installer un hyperviseur

Si vous n'avez pas encore installé d'hyperviseur, installez-en un maintenant :

• Hyper-V

• VirtualBox

Note: Hyper-V peut fonctionner sur trois versions de Windows 10: Windows 10 Entreprise, Windows 10 Professionnel et Windows 10 Éducation.

Installer Minikube en utilisant Chocolatey

La façon la plus simple d'installer Minikube sur Windows est d'utiliser Chocolatey (exécuté avec les droits administrateur) :

choco install minikube

Une fois l'installation de Minikube terminée, fermez la session CLI en cours et redémarrez. Minikube devrait avoir été ajouté à votre path automatiquement.

Installer Minikube avec Windows Installer

Pour installer manuellement Minikube sur Windows à l'aide de Windows Installer, téléchargez minikube-installer.exe et exécutez l'Installer.

Installer Minikube manuellement

Pour installer Minikube manuellement sur Windows, téléchargez minikube-windows-amd64, renommez-le en minikube.exe, et ajoutez-le à votre path.

Confirmer l'installation

Pour confirmer la réussite de l'installation d'un hyperviseur et d'un mini-cube, vous pouvez exécuter la commande suivante pour démarrer un cluster Kubernetes local :

Note: Pour définir le --driver avec minikube start, entrez le nom de l'hyperviseur que vous avez installé en minuscules où <driver_name> est mentionné ci-dessous. Une liste complète des valeurs --driver est disponible dans la documentation spécifiant le pilote VM.

minikube start --driver=<driver_name>

Une fois minikube start terminé, exécutez la commande ci-dessous pour vérifier l'état du cluster :

minikube status

Si votre cluster est en cours d'exécution, la sortie de minikube status devrait être similaire à :

host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured

Après avoir vérifié si Minikube fonctionne avec l'hyperviseur choisi, vous pouvez continuer à utiliser Minikube ou arrêter votre cluster. Pour arrêter votre cluster, exécutez :

minikube stop

Tout nettoyer pour recommencer à zéro

Si vous avez déjà installé minikube, exécutez :

minikube start

Si cette commande renvoie une erreur :

machine does not exist

Vous devez supprimer les fichiers de configuration :

rm -rf ~/.minikube

A suivre

Exécutez Kubernetes localement via Minikube