Premiers pas avec Kubernetes

Installer sur Google Cloud

Kubernetes a été initialement développé par Google pour alimenter leur Container Engine. En tant que tels, les clusters Kubernetes sont un citoyen de première classe chez Google.

La création d’un cluster Kubernetes dans le moteur de conteneur nécessite la commande gcloud du [Google Cloud SDK][gcloudsdk]. Pour installer cette commande localement, utilisez l’une des options suivantes :

  • utilisez l’installateur interactif (le moyen le plus simple pour les nouveaux arrivants) :
curl https://sdk.cloud.google.com | bash
exec -l $SHELL
gcloud init
  • téléchargez le SDK depuis https://cloud.google.com/sdk/ et exécutez le fichier d’installation approprié.

    For example, to install in Linux (x86_64):

curl -Lo gcloud-sdk.tar.gz https://dl.google.com/dl/cloudsdk/channels/rapid/downloads/google-cloud-sdk-142.0.0-linux-x86_64.tar.gz
tar xvf ./gcloud-sdk.tar.gz
./google-cloud-sdk/install.sh
gcloud init

Une fois gcloud installé, créez un cluster Kubernetes avec :

# Give our cluster a name
CLUSTER_NAME=example-cluster

# Number of machines in the cluster.
NUM_NODES=3
    
gcloud container clusters create $CLUSTER_NAME --num_nodes=$NUM_VMS

[gcloudsdk] : https://cloud.google.com/sdk/

Kubectl en ligne de commande

Une fois que vous avez un cluster en cours d’exécution, vous pouvez le gérer avec la commande kubectl. La plupart des commandes que vous pouvez obtenir avec la commande kubectl --help, mais je vous montre les commandes les plus courantes, pour gérer et obtenir des informations sur votre cluster, vos nœuds, vos pods, vos services et vos étiquettes.


Pour obtenir des informations sur le cluster, vous pouvez utiliser la commande suivante

kubectl cluster-info

Il vous montrera l’adresse et le port d’exécution.


Pour obtenir de brèves informations sur les nœuds, les pods, les services, etc. ou sur toute ressource ayant obtenu une place sur le cluster, vous pouvez utiliser la commande suivante

kubectl get {nodes, pods, services, ...}

La sortie principalement une ligne par ressource.


Pour obtenir une description détaillée des ressources, vous pouvez utiliser le drapeau describe pour le kubectl

kubectl describe {nodes, pods, ...}

Les applications déployées ne sont visibles qu’à l’intérieur du cluster, donc si vous souhaitez obtenir la sortie de l’extérieur du cluster, vous devez créer une route entre le terminal et le cluster kubernetes.

kubectl proxy

Cela ouvrira une API, où nous pourrons tout obtenir du cluster. Si vous souhaitez obtenir le nom des pods pour obtenir des informations, vous devez utiliser la commande suivante :

kubectl get pods -o go-template --template '{{range .items}}{{.metadata.name}}{{"\n"}}{{end}}'

Il listera les pods pour une utilisation ultérieure.

curl http://localhost:8001/api/v1/proxy/namespaces/default/pods/{pod_name}/

Deux autres commandes courantes sont l’obtention des journaux et l’exécution d’une commande depuis/dans l’application conteneurisée.

kubectl logs {pod_name}
kubectl exec {pod_name} {command}

La configuration de la complétion des onglets pour votre shell peut être effectuée avec :

source <(kubectl completion zsh)   # if you're using zsh
source <(kubectl completion bash)  # if you're using bash

ou plus par programmation :

source <(kubectl completion "${0/-/}")

Installer Minikube

Minikube crée un cluster local de machines virtuelles sur lesquelles exécuter Kubernetes. C’est la méthode la plus simple pour vous salir les mains avec Kubernetes sur votre machine locale.

La documentation de Minikube est disponible sur http://kubernetes.io/docs/getting-started-guides/minikube/

Conditions

  • Sur macOS, les hyperviseurs [pilote xhyve][1], [VirtualBox][2] ou [VMware Fusion][3]
  • Sous Linux, hyperviseurs [VirtualBox][2] ou [KVM][4]
  • Sur les hyperviseurs Windows [VirtualBox][2] ou [Hyper-V][5]
  • Virtualisation VT-x/AMD-v activée

Pour vérifier si la prise en charge de la virtualisation est activée, exécutez la commande appropriée ci-dessous. La commande affichera quelque chose si la virtualisation est activée.

# On Linux
cat /proc/cpuinfo | grep 'vmx\|svm'
# On OSX
sysctl -a | grep machdep.cpu.features | grep VMX

#Mise en place

Minikube est un binaire unique. Ainsi, l’installation est aussi simple que de télécharger le binaire et de le placer sur votre chemin.

# Specify the version of minikube to download.
# Latest version can be retrieved from 
# https://github.com/kubernetes/minikube/releases
VERSION=v0.16.0

# If on Linux
OS=linux  
# If on OSX
# OS=darwin

# URL to download minikube binary from
URL=https://storage.googleapis.com/minikube/releases/$VERSION/minikube-$OS-amd64

# Download binary and place in path.
curl -Lo minikube $URL 
chmod +x minikube 
sudo mv minikube /usr/local/bin/

Utilisation

Pour démarrer un nouveau cluster :

minikube start

Cela créera un nouveau cluster de machines virtuelles locales avec Kubernetes déjà installé et configuré.

Vous pouvez accéder au tableau de bord Kubernetes avec :

minikube dashboard

Minikube crée un contexte associé pour kubectl qui peut être utilisé avec :

kubectl config use-context minikube

Une fois prêt, le Kubernetes local peut être utilisé :

kubectl run hello-minikube --image=gcr.io/google_containers/echoserver:1.4 --port=8080
kubectl expose deployment hello-minikube --type=NodePort
curl $(minikube service hello-minikube --url)

Pour arrêter le cluster local :

minikube stop

Pour supprimer le cluster local, notez qu’une nouvelle adresse IP sera allouée après sa création :

minikube delete

[1] : https://github.com/kubernetes/minikube/blob/master/docs/drivers.md#xhyve-driver [2] : https://www.virtualbox.org/wiki/Downloads [3] : https://www.vmware.com/products/fusion.html [4] : https://github.com/kubernetes/minikube/blob/master/docs/drivers.md#kvm-driver [5] : https://github.com/kubernetes/minikube/blob/master/docs/drivers.md#hyperV-driver

Configurer kubectl

Un cluster Kubernetes est contrôlé à l’aide de la commande kubectl. La méthode de configuration de kubectl dépend de l’endroit où Kubernetes est installé.

Google Cloud (moteur de conteneurs)

Pour installer kubectl à l’aide du SDK Google Cloud :

gcloud components install kubectl

Pour configurer kubectl afin de contrôler un cluster Kubernetes existant dans Container Engine :

gcloud container clusters get-credentials $CLUSTER_NAME

Minikube

Lors de l’utilisation de minikube, le binaire kubectl doit être téléchargé manuellement et placé dans le chemin.

# Version of Kubernetes.
K8S_VERSION=$(curl -sS https://storage.googleapis.com/kubernetes-release/release/stable.txt)
# Operating System. Can be one of {linux, darwin}
GOOS=linux
# Architecture. Can be one of {386, amd64, arm64, ppc641e}
GOARCH=amd64

# Download and place in path.
curl -Lo kubectl http://storage.googleapis.com/kubernetes-release/release/${K8S_VERSION}/bin/${GOOS}/${GOARCH}/kubectl
chmod +x kubectl
sudo mv kubectl /usr/local/bin/

Le binaire minikube configure automatiquement kubectl lors du démarrage d’un cluster.

minikube start
# kubectl is now ready to use!

Bonjour le monde

Une fois que votre cluster Kubernetes est en cours d’exécution et que kubectl est configuré, vous pouvez exécuter votre première application en quelques étapes. Cela peut être fait en utilisant les [commandes impératives][1] qui n’ont pas besoin de fichiers de configuration.

Pour exécuter une application, vous devez fournir un nom de déploiement (bootcamp), l’emplacement de l’image du conteneur (docker.io/jocatalin/kubernetes-bootcamp:v1) et le port (8080)

$ kubectl run bootcamp --image=docker.io/jocatalin/kubernetes-bootcamp:v1 --port=8080

Confirmez que cela a fonctionné avec:

$ kubectl get deployments
NAME                  DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
bootcamp               1         1         1            1         6s

Pour exposer votre application et la rendre accessible depuis l’extérieur, procédez comme suit :

$ kubectl expose deployment/bootcamp --type="LoadBalancer" --port 8080

Confirmez que cela a fonctionné avec:

$ kubectl get services
NAME                  CLUSTER-IP   EXTERNAL-IP         PORT(S)    AGE
kubernetes            10.0.0.1     <none>              443/TCP    3m
bootcamp              10.3.245.61  104.155.111.170     8080:32452/TCP   2m

Pour accéder aux services, utilisez l’adresse IP externe et le port d’application, par ex. comme ça:

$ export EXTERNAL_IP=$(kubectl get service bootcamp --output=jsonpath='{.status.loadBalancer.ingress[0].ip}')
$ export PORT=$(kubectl get services --output=jsonpath='{.items[0].spec.ports[0].port}')
$ curl "$EXTERNAL_IP:$PORT"
Hello Kubernetes bootcamp! | Running on: bootcamp-390780338-2fhnk | v=1

La même chose pourrait être faite manuellement avec les données fournies dans :

$ kubectl describe service bootcamp
Name:                   bootcamp
Namespace:              default
Labels:                 run=bootcamp
Selector:               run=bootcamp
Type:                   LoadBalancer
IP:                     10.3.245.61
LoadBalancer Ingress:   104.155.111.170
Port:                   <unset> 8080/TCP
NodePort:               <unset> 32452/TCP
Endpoints:              10.0.0.3:8080
... events and details left out ....

$ export NODE=104.155.111.170
$ export PORT=8080

Une fois que cela a fonctionné, vous pouvez faire évoluer votre application avec :

$ kubectl scale deployments/bootcamp --replicas=4

Et vérifiez le résultat avec :

$ kubectl get deployments
NAME                  DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
bootcamp               4         4         4            4         30s

$ curl "$EXTERNAL_IP:$PORT"
Hello Kubernetes bootcamp! | Running on: bootcamp-390780338-2fhnk | v=1
$ curl "$EXTERNAL_IP:$PORT"
Hello Kubernetes bootcamp! | Running on: bootcamp-390780338-gmtv5 | v=1

Attention au changement d’identifiant de pod.

Pour pousser une nouvelle version de l’application, exécutez :

kubectl set image deployments/bootcamp bootcamp=jocatalin/kubernetes-bootcamp:v2

Et validez avec :

$ curl "$EXTERNAL_IP:$PORT"
Hello Kubernetes bootcamp! | Running on: bootcamp-284539476-gafwev3 | v=2

Le nettoyage est enfin fait avec :

$ kubectl delete deployment bootcamp
$ kubectl delete service bootcamp

[1] : https://kubernetes.io/docs/concepts/tools/kubectl/object-management-using-imperative-commands/