# ***Kubernetes***

Bien que chaque ***pod*** ait une ***adresse IP unique***, ces adresses IP ne sont pas exposées en dehors du ***cluster sans service***. Les services permettent à vos applications de recevoir du trafic. Les services peuvent être exposés de différentes manières en spécifiant un type dans la ServiceSpec :

* **ClusterIP** (par défaut) - Expose le service sur une adresse IP interne dans le cluster. Ce type rend le service uniquement accessible depuis le cluster.
* **NodePort** - Expose le service sur le même port de chaque nœud sélectionné dans le cluster à l'aide de ***NAT***. Rend un service accessible depuis l'extérieur du cluster à l'aide de ***NodeIP*** :***NodePort***. Surensemble de ***ClusterIP***.
* **LoadBalancer** - Crée un équilibreur de charge externe dans le cloud actuel (si pris en charge) et attribue une adresse IP externe fixe au service. Surensemble de ***NodePort***.

## ***Installer kubernetes***

* sudo apt update
* sudo apt -y upgrade
* sudo apt -y install curl 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 /etc/apt/sources.list.d/kubernetes.list
* sudo apt update
* sudo apt -y install vim git curl wget kubelet kubeadm kubectl
* sudo apt-mark hold kubelet kubeadm kubectl

* ***1- Create Kubernetes Secret:***

 
 apiVersion: v1
kind: Secret
metadata:
  name: mysql-secret
type: kubernetes.io/basic-auth
stringData:
  password: *******
 

* nano mysql-secret.yaml
* kubectl apply -f mysql-secret.yaml

* ***2- Créer un volume persistant et une revendication de volume:***

apiVersion: v1
kind: PersistentVolume
metadata:
  name: mysql-pv-volume
  labels:
    type: local
spec:
  storageClassName: manual
  capacity:
    storage: 20Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pv-claim
spec:
  storageClassName: manual
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 20Gi

* nano mysql-storage.yaml
* kubectl apply -f mysql-storage.yaml

* ***3- Create MySQL Deployment***

* ***3.1 Créez le fichier de déploiement. Le fichier de déploiement définit les ressources que le déploiement MySQL utilisera.***

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mysql
spec:
  selector:
    matchLabels:
      app: mysql
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
      - image: mysql:5.6
        name: mysql
        env:
        - name: MYSQL_ROOT_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-secret
              key: password
        ports:
        - containerPort: 3306
          name: mysql
        volumeMounts:
        - name: mysql-persistent-storage
          mountPath: /var/lib/mysql
      volumes:
      - name: mysql-persistent-storage
        persistentVolumeClaim:
          claimName: mysql-pv-claim
---
apiVersion: v1
kind: Service
metadata:
  name: mysql
spec:
  ports:
  - port: 3306
  selector:
    app: mysql
    

* nano mysql-deployment.yaml
* kubectl apply -f mysql-deployment.yaml

* Pour accéder à l'instance MySQL, accédez au pod créé par le déploiement. Utiliser la commande suivant:

* kubectl get pod

* Obtenez un shell pour le conteneur en cours d'exécution:

* kubectl exec -it shell-demo -- /bin/bash

* Pour accéder au shell MySQL tapez la commande suivante :

* mysql -p

* ***4- Supprimer votre instance MySQL***

* kubectl delete deployment,svc mysql
* kubectl delete pvc mysql-pv-claim
* kubectl delete pv mysql-pv-volume
* kubectl delete secret mysql-secret

## ***Déployer php sur le cluster Kubernetes***

apiVersion: v1
kind: Service
metadata:
  name: php
  labels:
    tier: backend
spec:
  selector:
    app: php
    tier: backend
  ports:
  - protocol: TCP
    port: 9000

## ***Déployer le serveur Web Apache et PHP sur le cluster Kubernetes***

apiVersion: v1
kind: service 
metadata:
  name: httpd-service-devops
  namespace: httpd-namespace-devops
  labels:
    app: apache_app
spec:
  type: NodePort
  selector:
    app: apache_app
  ports:
    - port: 80
      targetPort: 80
      nodePort: 30004

---

apiVersion: apps/v1
kind: Deployment
metadata:
  name: httpd-deployment-devops
  namespace: httpd-namespace-devops
spec: 
  replicas: 2 
  selector:
    matchLabels:
      app: apache_app
  template:
    metadata:
      labels:
        app: apache_app
  spec:
   containers:
    - name: httpd-container-devops
      image: httpd:latest
      ports:
       - containerPort: 80
       
       

* nano apache-dev.yaml

- On doit cree un namespace:

* kubectl create ns httpd-namespace-devops
* kubectl get ns
* kubectl apply -f apache-dev.yaml
* kubectl get pods -n httpd-namespace-devops
* kubectl describe pods -n httpd-namespace-devops
* kubectl get pods -n httpd-namespace-devops
* kubectl service

### ***Déployer Ingress***

Un ***Ingress*** est un objet Kubernetes qui ***gère l'accès externe*** aux services dans un cluster, généralement du trafic ***HTTP***.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: test-ingress
spec:
  defaultBackend:
    service:
      name: tresotomatik
      port:
        number: 80

## ***k9s***

K9s surveille votre cluster Kubernetes de façon permanente. Il vous offrira notamment :

* Une bonne compréhension de votre cluster K8s et une bonne ***visibilité de l’état des ressources***
* Une ***navigation facilitée*** à travers les ressources du cluster
* Une possibilité d'***interagir simplement*** avec ces ressources.

###### ***Installer K9s***

* sudo apt install k9s

+ Une fois K9s installé, vous pouvez le lancer depuis le terminal avec la commande:

* k9s

K9s affiche différentes informations sur les ressources consultées.
Par example: son âge, le node sur lequel il tourne, la quantité de RAM etc.
Ces informations sont accessibles par les suivants commandes:

* kubectl get pods
* kubectl top pods

### ***Installer Minikube***

***Minikube*** est une implémentation Kubernetes légère qui crée une ***machine virtuelle*** sur votre machine locale et déploie un ***cluster simple*** contenant ***un seul nœud***.

* wget https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
* chmod +x minikube-linux-amd64
* sudo mv minikube-linux-amd64 /usr/local/bin/minikube
* minikube start
* kubectl cluster-info

* Les ***nœuds*** communiquent avec le maître à l'aide de l'***API Kubernetes***