Formation Kubernetes Op��rateur

Concernant ces supports de cours

Supports de cours réalisés par Particule

Kubernetes : Projet, gouvernance et communauté

Kubernetes

  • COE développé par Google, devenu open source en 2014
  • Adapté à tout type d'environnement
  • Devenu populaire en très peu de temps
  • Premier projet de la CNCF

CNCF

The Foundation’s mission is to create and drive the adoption of a new computing paradigm that is optimized for modern distributed systems environments capable of scaling to tens of thousands of self healing multi-tenant nodes.

CNCF : Prérequis

  • Distribuer sous forme de conteneurs
  • Gestion dynamique de la configuration
  • Orienté micro services

CNCF : Les rôles

  • Intendance des projets
  • Faire grossir et évoluer l'écosystème
  • Rendre la technologie accessible
  • Promouvoir la technologie

OCI

  • Créé sous la Linux Fondation
  • But : Créer un standard Open Source concernant la manière de "runner" et le format des conteneurs et images
  • Non lié à des produits
  • Non lié à des COE
  • runC a été donné par Docker à l'OCI comme implémentions de base

Kubernetes : Projet

Kubernetes : Projet

Kubernetes : Cycle de développement

Kubernetes : Communauté

Kubernetes : KubeCon

La CNCF organise trois KubeCon par an :

  • Amérique du Nord (San Diego, Seattle, etc)
  • Europe (Berlin, Barcelone, Amsterdam etc)
  • Chine

Kubernetes : Architecture

Kubernetes : Composants

  • Kubernetes est écrit en Go, compilé statiquement.
  • Un ensemble de binaires sans dépendance
  • Faciles à conteneuriser et à packager
  • Peut se déployer uniquement avec des conteneurs sans dépendance d'OS

Kubernetes : Composants du Control Plane

  • etcd: Base de données
  • kube-apiserver : API server qui permet la configuration d'objets Kubernetes (Pod, Service, Deployment, etc.)
  • kube-proxy : Permet le forwarding TCP/UDP et le load balancing entre les services et les backends (Pods)
  • kube-scheduler : Implémente les fonctionnalités de scheduling
  • kube-controller-manager : Responsable de l'état du cluster, boucle infinie qui régule l'état du cluster afin d'atteindre un état désiré

Kubernetes : Composants du Control Plane

Kubernetes : Composants du Control Plane

Kubernetes : etcd

  • Base de données de type Clé/Valeur (Key Value Store)
  • Stocke l'état d'un cluster Kubernetes
  • Point sensible (stateful) d'un cluster Kubernetes
  • Projet intégré à la CNCF

Kubernetes : kube-apiserver

  • Les configurations d'objets (Pods, Service, RC, etc.) se font via l'API server
  • Un point d'accès à l'état du cluster aux autres composants via une API REST
  • Tous les composants sont reliés à l'API server

Kubernetes : kube-scheduler

  • Planifie les ressources sur le cluster
  • En fonction de règles implicites (CPU, RAM, stockage disponible, etc.)
  • En fonction de règles explicites (règles d'affinité et anti-affinité, labels, etc.)

Kubernetes : kube-proxy

  • Responsable de la publication de services
  • Utilise iptables
  • Route les paquets à destination des pods et réalise le load balancing TCP/UDP

Kubernetes : kube-proxy

Kubernetes : kube-controller-manager

  • Boucle infinie qui contrôle l'état d'un cluster
  • Effectue des opérations pour atteindre un état donné
  • De base dans Kubernetes : replication controller, endpoints controller, namespace controller et serviceaccounts controller

Kubernetes : Autres composants

  • kubelet : Service "agent" fonctionnant sur tous les nœuds et assure le fonctionnement des autres services
  • kubectl : Ligne de commande permettant de piloter un cluster Kubernetes

Kubernetes : Kubelet

  • Service principal de Kubernetes
  • Permet à Kubernetes de s'auto configurer :
    • Surveille un dossier contenant les manifests (fichiers YAML des différents composant de Kubernetes).
    • Applique les modifications si besoin (upgrade, rollback).
  • Surveille l'état des services du cluster via l'API server (kube-apiserver).

Kubernetes: Network

Kubernetes n'implémente pas de solution réseau par défaut, mais s'appuie sur des solutions tierces qui implémentent les fonctionnalités suivantes:

  • Chaque pods reçoit sa propre adresse IP
  • Les pods peuvent communiquer directement sans NAT

Kubernetes : Aujourd'hui

  • Version 1.18.x : stable en production
  • Solution complète et une des plus utilisées
  • Éprouvée par Google

Kubernetes : Installation

Kubernetes : Minikube

  • Outil permettant de démarrer rapidement un cluster mono-node Kubernetes localement
  • Execute Kubernetes dans une machine virtuelle
  • Nécessite des outils de virtualisation (VirtualBox, VMware Fusion, KVM, etc...)
  • Supporte plusieurs systèmes d'exploitation : Linux, Mac OS, Windows
  • Installation : https://github.com/kubernetes/minikube#Installation

Kubernetes : Minikube

  • Création d'un cluster Kubernetes
$ minikube get-k8s-versions
The following Kubernetes versions are available when using the localkube bootstrapper:
  - v1.16.1
  - v1.15.5
  - v1.14.3
  - v1.9.4
  - v1.9.0

Kubernetes : Minikube

$minikube start --kubernetes-version="v1.16.1"
Starting local Kubernetes v1.16.1 cluster...
Starting VM...
Getting VM IP address...
[...]
Connecting to cluster...
Setting up kubeconfig...
Starting cluster components...
Kubectl is now configured to use the cluster.
Loading cached images from config file.

Kubernetes : Minikube

  • Effectuer un diagnostic basique du cluster
$ kubectl version
Client Version: v1.16.1
Server Version: v1.16.1

Kubernetes : Minikube

$ kubectl get componentstatuses
NAME                      STATUS    MESSAGE              ERROR
controller-manager   Healthy      ok
scheduler                  Healthy      ok
etcd-0                       Healthy      {"health": "true"}

Installation de Kubernetes

  • De nombreuses ressources présentes pour le déploiement de Kubernetes dans un environnement de production

  • Un des outils est kubeadm utilisé pour rapidement démarrer un cluster Kubernetes

Installation de Kubernetes avec Kubeadm

Kubeadm

  • Installer les composants Kubernetes (kubeadm, kubectl, kubelet) : https://kubernetes.io/docs/setup/independent/install-kubeadm/
  • Exécuter kubeadm init sur le noeud master
  • Exécuter kubeadm join sur les autres noeuds (avec le token fournir par la commande kubeadm init)
  • Copier le fichier de configuration généré par kubeadm init
  • Installer le plugin Réseau

Kubeadm

En plus de l'installation de Kubernetes, Kubeadm peut :

  • Renouveler les certificats du Control Plane
  • Générer des certificats utilisateurs signés par Kubernetes
  • Effectuer des upgrades de Kubernetes (kubeadm upgrade)

Kubernetes managés "as a Service"

Installation de Kubernetes

Introduction à Sonobuoy

Kubectl : Advanced Usage

  • Il est possible de mettre à jour un service sans incident grâce ce qui est appelé le rolling-update.
  • Avec les rolling updates, les ressources qu'expose un objet Service se mettent à jour progressivement.
  • Seuls les objets Deployment, DaemonSet et StatefulSet support les rolling updates.
  • Les arguments maxSurge et maxUnavailabe définissent le rythme du rolling update.
  • La commande kubectl rollout permet de suivre les rolling updates effectués.

Kubectl : Advanced Usage

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
spec:
  selector:
    matchLabels:
      app: frontend
  replicas: 2
  strategy:
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
    type: RollingUpdate
  template:
    metadata:
      name: nginx
      labels:
        app: frontend
    spec:
      containers:
        - image: nginx:1.9.1
          name: nginx

Kubectl : Advanced Usage

$ kubectl create -f nginx.yaml --record
deployment.apps/nginx created

Kubectl : Advanced Usage

  • Il est possible d'augmenter le nombre de pods avec la commande kubectl scale :
kubectl scale --replicas=5 deployment nginx
  • Il est possible de changer l'image d'un container utilisée par un Deployment :
kubectl set image deployment nginx nginx=nginx:1.15

Kubectl : Advanced Usage

  • Dry run. Afficher les objets de l'API correspondant sans les créer :

kubectl run nginx --image=nginx --dry-run

  • Démarrer un container en utiliser une commande différente et des arguments différents :
kubectl run nginx --image=nginx \
--command -- <cmd> <arg1> ... <argN>
  • Démarrer un Cron Job qui calcule π et l'affiche toutes les 5 minutes :
kubectl run pi --schedule="0/5 * * * ?" --image=perl --restart=OnFailure \
-- perl -Mbignum=bpi -wle 'print bpi(2000)'

Kubectl : Advanced Usage

  • Se connecter à un container:
kubectl run -it busybox --image=busybox -- sh
  • S'attacher à un container existant :
kubectl attach my-pod -i
  • Accéder à un service via un port :
kubectl port-forward my-svc 6000

Kubectl : Logging

  • Utiliser kubectl pour diagnostiquer les applications et le cluster kubernetes :
kubectl cluster-info
kubectl get events
kubectl describe node <NODE_NAME>
kubectl  logs (-f) <POD_NAME>

Kubectl : Maintenance

  • Obtenir la liste des noeuds ainsi que les informations détaillées :
kubectl get nodes
kubectl describe nodes

Kubectl : Maintenance

  • Marquer le noeud comme unschedulable (+ drainer les pods) et schedulable :
kubectl cordon <NODE_NAME>
kubectl drain <NDOE_NAME>
kubectl uncordon <NODE_NAME>

Kubernetes : Securité et Controle d'accès

Authentication & Autorisation

  • RBAC (Role Based Access Control)
  • ABAC (Attribute-based access control)
  • WebHook
  • Certificates
  • Token

RBAC

3 entités sont utilisées :

  • Utilisateurs représentés par les Users ou les ServiceAccounts
  • Resources représentées par les Deployments, Pods, Services, etc...
  • les différentes opérations possibles : create, list, get, delete, watch, patch

RBAC

Service Accounts

  • Objet Kubernetes permettant d'identifier une application s'éxecutant dans un pod
  • Par défaut, un ServiceAccount par namespace
  • Le ServiceAccount est formatté ainsi :
system:serviceaccount:<namespace>:<service_account_name>

Service Accounts

apiVersion: v1
kind: ServiceAccount
metadata:
    name: default
    namespace: default

Role

  • L'objet Role est un ensemble de règles permettant de définir quelle opération (ou verbe) peut être effectuée et sur quelle ressource
  • Le Role ne s'applique qu'à un seul namespace et les ressources liées à ce namespace

Role

kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  namespace: default
  name: pod-reader
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "watch", "list"]

RoleBinding

  • L'objet RoleBinding va allouer à un User, ServiceAccount ou un groupe les permissions dans l'objet Role associé
  • Un objet RoleBinding doit référencer un Role dans le même namespace.
  • L'objet roleRef spécifié dans le RoleBinding est celui qui crée le liaison

RoleBinding

kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: read-pods
  namespace: default
subjects:
- kind: User
  name: jane
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

ClusterRole

  • L'objet ClusterRole est similaire au Role à la différence qu'il n'est pas limité à un seul namespace
  • Il permet d'accéder à des ressources non limitées à un namespace comme les nodes

ClusterRole

kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: secret-reader
rules:
- apiGroups: [""]
  resources: ["secrets"]
  verbs: ["get", "watch", "list"]

ClusterRoleBinding

kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: salme-reads-all-pods
subjects:
- kind: User
  name: jsalmeron
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: ClusterRole
  name: secret-reader
  apiGroup: rbac.authorization.k8s.io

RBAC

kubectl auth can-i get pods /
--namespace=default /
--as=spesnova@example.com

NetworkPolicies

  • La ressource NetworkPolicy est une spécification permettant de définir comment un ensemble de pods communiquent entre eux ou avec d'autres endpoints
  • Le NetworkPolicy utilisent les labels pour sélectionner les pods sur lesquels s'appliquent les règles qui définissent le trafic alloué sur les pods sélectionnés
  • Le NetworkPolicy est générique et fait partie de l'API Kubernetes. Il est nécessaire que le plugin réseau déployé supporte cette spécification

NetworkPolicies

NetworkPolicies

  • Exemple de NetworkPolicy permettant de blocker le trafic entrant :
kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: web-deny-all
spec:
  podSelector:
    matchLabels:
      app: web
  ingress: []

PodSecurityPolicies

  • Permet de contrôler les privilèges d'un pod
  • Permet de définir ce qui est autorisé pendant l'exécution du pod
  • A utiliser dans un contexte multi-tenant et quand les pods ne viennent pas d'un tiers de confiance
  • Peut-être combiné avec le RBAC
  • Attention: Activer cette fonctionnalité peut endommager votre environnement
  • Il faut une PSP par défaut

PodSecurityPolicies

apiVersion: policy/v1beta1
kind: PodSecurityPolicy
metadata:
  name: restricted
spec:
  privileged: false
  allowPrivilegeEscalation: false
  requiredDropCapabilities:
    - ALL
  hostNetwork: false
  hostIPC: false
  hostPID: false
  runAsUser:
    rule: 'MustRunAsNonRoot'
  readOnlyRootFilesystem: false

Admission Controllers

  • Interceptes les requêtes sur l'API Kubernetes
  • Peut effectuer des modifications si nécessaires
  • Conception personnalisée possible

Admission Controllers

  • DenyEscalatingExec
  • ImagePolicyWebhook
  • NodeRestriction
  • PodSecurityPolicy
  • SecurityContextDeny
  • ServiceAccount

Conclusion