virli/tutorial/k8s/setup.md

\newpage

Mise en place
=============

La mise en place d'un cluster Kubernetes ([prononcé
Ku-ber-né-tèce](https://github.com/kubernetes/kubernetes/issues/44308) en grec
ancien) est une opération qui peut s'avérer très longue et complexe, car elle
nécessite l'installation et la configuration de nombreux composants avant de
pouvoir être utilisé sereinement.

Cette opération n'étant pas très palpitante (c'est beaucoup de lecture de
documentations et d'heures passées à essayer de faire tomber en marche tous les
composants d'un seul coup), nous ne la verrons pas aujourd'hui.

D'ailleurs, dans le milieu professionnel, il est plutôt rare de voir des
entreprises investir dans la gestion de leur propre cluster Kubernetes. La
plupart des entreprises qui choisissent d'utiliser Kubernetes pour gérer leurs
infrastructures, choisissent de passer par un prestataire. L'entreprise délègue
donc la gestion de leur cluster à une autre entreprise, dont c'est la cœur de
métier. La plupart du temps, il va s'agir d'Amazon (via [Elastic Kubernetes
Service](https://aws.amazon.com/fr/eks/)), d'Azur ([Kubernetes
Service](https://azure.microsoft.com/fr-fr/services/kubernetes-service/)) ou
Google ([Kubernetes Engine](https://cloud.google.com/kubernetes-engine/)), mais
d'autres acteurs plus petits existent aussi
([OVHcloud](https://www.ovhcloud.com/fr/public-cloud/kubernetes/), ...).


Pour jouer aujourd'hui, deux solutions s'offrent à nous pour commencer à
utiliser Kubernetes facilement :

- Kubernetes in Docker (kind) : pour tenter l'aventure sur votre machine,
- Play With Kubernetes : si vous ne vous en sortez pas avec `kind`.


Kubernetes in Docker (kind)
---------------------------

`kind` est un projet permettant de lancer un cluster kubernetes directement via
Docker.

Pour commencer, il nous faudra télécharger le binaire (go, donc statique)
suivant (il existe pour Linux, macOS et Windows) :

<div lang="en-US">
```bash
curl -Lo kind https://github.com/kubernetes-sigs/kind/releases/download/v0.9.0/kind-$(uname)-amd64
chmod +x kind
```
</div>

Placez-le dans un endroit où il sera accessible de votre `$PATH`.

Notre prochaine étape est de décrire le cluster que l'on souhaite avoir : 1
master et 2 workers. Avant de lancer leur création.

<div lang="en-US">
```bash
cat > my-cluster.yml <<EOF
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
  extraPortMappings:
  - containerPort: 8080
    hostPort: 12345
  - containerPort: 30001
    hostPort: 30001
  - containerPort: 30002
    hostPort: 30002
- role: worker
- role: worker
EOF
kind create cluster --config my-cluster.yml
```
</div>

La création du cluster peut prendre quelques minutes.

Profitons-en pour télécharger `kubectl` :

<div lang="en-US">
```bash
curl -LO https://storage.googleapis.com/kubernetes-release/release/v1.19.4/bin/linux/amd64/kubectl
chmod +x kubectl
```
</div>

C'est via cette commande que nous interagirons principalement avec l'API de
Kubernetes.

Une fois que tout sera opérationnel, nous devrions obtenir :

<div lang="en-US">
```
42sh$ kubectl version
Client Version: version.Info{Major:"1", Minor:"19", GitVersion:"v1.19.3", GitCommit:"1e11e4a2108024935ecfcb2912226cedeafd99df", GitTreeState:"archive", BuildDate:"2020-11-18T12:02:06Z", GoVersion:"go1.15.5", Compiler:"gc", Platform:"linux/amd64"}
Server Version: version.Info{Major:"1", Minor:"19", GitVersion:"v1.19.1", GitCommit:"206bcadf021e76c27513500ca24182692aabd17e", GitTreeState:"clean", BuildDate:"2020-09-14T07:30:52Z", GoVersion:"go1.15", Compiler:"gc", Platform:"linux/amd64"}
```
</div>

Par défaut, `kubectl` va tenter de contacter le port local 2375, `kind` aura
pris soin de l'exposer pour vous au moment de la création du cluster.

Passez ensuite à la section 2 si vous avez réussi à mettre en place `kind`.

Play With Kubernetes
--------------------

De la même manière que pour les TP utilisant Docker, si vous avez des
difficultés pour réaliser les exercices sur vos machines, vous pouvez utiliser
le projet [Play With K8s](https://play-with-k8s.com/) qui vous donnera accès à
un bac à sable avec lequel vous pourrez réaliser tous les exercices de ce TP.

Il nous faut créer plusieurs instances, disons 3 : parmi elles, 1 instance sera
la master, nous l'utiliserons principalement, les deux autres ne feront
qu'exécuter des conteneurs, nous pourrons les oublier dès qu'on les aura
connectées au master.

Pour initialiser notre cluster Kubernetes, nous allons devoir créer notre
master. Pour cela, dans notre première instance, nous allons taper :

<div lang="en-US">
```bash
kubeadm init --apiserver-advertise-address $(hostname -i)
```
</div>

Cette action peut prendre quelques minutes, et devrait se finir, si tout se
passe bien, par :

<div lang="en-US">
```
Your Kubernetes master has initialized successfully!

To start using your cluster, you need to run (as a regular user):

  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  http://kubernetes.io/docs/admin/addons/

You can now join any number of machines by running the following on each node
  as root:

kubeadm join --token SOMETOKEN SOMEIPADDRESS --discovery-token-ca-cert-hash SOMESHAHASH
```
</div>

Recopions ensuite la commande `kubeadm join ...` donnée dans le terminal, dans
nos deux autres instances. Cela permettra aux machines de se connecter au
master.

Dernière étape pour la mise en place de notre cluster, il s'agit de définir un
profil de politique réseau, sur le master (nous n'exécuterons plus de commande
sur les autres workers) :

<div lang="en-US">
```bash
kubectl apply -n kube-system -f \
  "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 |tr -d '\n')"
```
</div>


Minikube, Docker for Mac/Windows, MicroK8s, ...
-----------------------------------------------

Si les solutions précédentes ne sont pas adaptées à votre usage, de nombreuses
autres applications permettent de mettre en place un cluster plus ou moins
complet, facilement.

Vous pouvez tenter d'utiliser
[minikube](https://kubernetes.io/docs/setup/learning-environment/minikube/),
[microk8s](https://microk8s.io/), ... Notez également que *Docker for Mac* et
*Docker for Windows* intègrent aussi Kubernetes depuis quelques versions ;
il convient de l'activer dans les préférences de l'application.