Commandes de création Kubernetes

Introduction

La commande kubectl create est un outil essentiel pour créer des ressources Kubernetes. Elle utilise des fichiers YAML ou JSON pour définir des ressources telles que des namespaces, des déploiements, des services, des secrets et des ConfigMaps. Dans ce labo (LabEx), vous apprendrez à créer ces ressources étape par étape et à comprendre leur rôle dans Kubernetes.

À la fin de ce labo (LabEx), vous aurez :

Démarré et vérifié un cluster Minikube.
Créé et vérifié diverses ressources Kubernetes en utilisant kubectl create.

Démarrer Minikube et vérifier le cluster

Avant de travailler avec Kubernetes, vous avez besoin d'un cluster en cours d'exécution. Minikube fournit un cluster Kubernetes local léger.

Accédez à votre répertoire de projet :

Ouvrez votre terminal et accédez au répertoire de travail par défaut :
```
cd /home/labex/project
```
Démarrez Minikube :

Démarrez Minikube pour initialiser le cluster :
```
minikube start
```
- Minikube crée un cluster Kubernetes à un seul nœud. Cette étape peut prendre quelques minutes.
Vérifiez l'état de Minikube :

Vérifiez si Minikube a démarré avec succès :
```
minikube status
```
Recherchez des composants tels que apiserver et kubelet listés comme Running (en cours d'exécution).
Confirmez la configuration de Kubernetes :

Assurez-vous que kubectl est connecté au cluster Minikube :
```
kubectl cluster-info
```
Cela affiche des détails sur le serveur d'API et les autres composants.

Si Minikube ne parvient pas à démarrer, utilisez minikube delete pour réinitialiser et réessayez.

Explorer la commande kubectl create

La commande kubectl create propose plusieurs sous-commandes pour créer des ressources Kubernetes. Elle facilite la gestion de la création de ressources telles que des namespaces, des déploiements, des services, des secrets et des ConfigMaps.

Exécutez la commande suivante pour afficher les sous-commandes disponibles de kubectl create :

kubectl create -h

Vous verrez la sortie suivante :

Create a resource from a file or from stdin.

JSON and YAML formats are accepted.

Examples:
  ## Create a pod using the data in pod.json
  kubectl create -f./pod.json

  ## Create a pod based on the JSON passed into stdin
  cat pod.json | kubectl create -f -

  ## Edit the data in registry.yaml in JSON then create the resource using the edited data
  kubectl create -f registry.yaml --edit -o json

Available Commands:
  clusterrole           Create a cluster role
  clusterrolebinding    Create a cluster role binding for a particular cluster role
  configmap             Create a config map from a local file, directory or literal value
  cronjob               Create a cron job with the specified name
  deployment            Create a deployment with the specified name
  ingress               Create an ingress with the specified name
  job                   Create a job with the specified name
  namespace             Create a namespace with the specified name
  poddisruptionbudget   Create a pod disruption budget with the specified name
  priorityclass         Create a priority class with the specified name
  quota                 Create a quota with the specified name
  role                  Create a role with single rule
  rolebinding           Create a role binding for a particular role or cluster role
  secret                Create a secret using specified subcommand
  service               Create a service using a specified subcommand
  serviceaccount        Create a service account with the specified name
  token                 Request a service account token

Passez en revue les sous-commandes disponibles et leurs descriptions pour comprendre comment utiliser kubectl create.

Créer un namespace

Les namespaces vous permettent d'organiser et d'isoler les ressources dans Kubernetes.

Créer un fichier de définition de namespace :

Ouvrez un nouveau fichier nommé namespace.yaml :
```
nano namespace.yaml
```
Définir le namespace :

Ajoutez le contenu suivant :
```
apiVersion: v1
kind: Namespace
metadata:
  name: mynamespace
```
Enregistrez le fichier en appuyant sur Ctrl+X, puis Y, et Entrée.
Appliquer le namespace :

Créez le namespace :
```
kubectl create -f namespace.yaml
```
Vérifier le namespace :

Vérifiez la liste des namespaces :
```
kubectl get namespaces
```
Confirmez que mynamespace apparaît dans la sortie.

Créer un déploiement (Deployment)

Les déploiements (deployments) gèrent et maintiennent l'état souhaité des pods.

Créer un fichier de définition de déploiement :

Ouvrez un fichier nommé deployment.yaml :
```
nano deployment.yaml
```

Définir le déploiement :

Ajoutez le contenu suivant pour déployer trois replicas d'un conteneur Nginx :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mydeployment
  namespace: mynamespace
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
        - name: nginx-container
          image: nginx

Enregistrez le fichier.

Appliquer le déploiement :

Créez le déploiement :
```
kubectl create -f deployment.yaml
```
Vérifier le déploiement :

Vérifiez le déploiement et ses pods :
```
kubectl get deployments -n mynamespace
kubectl get pods -n mynamespace
```
Assurez-vous que trois pods sont en cours d'exécution.

Créer un service

Un service (service) fournit un accès réseau stable à un ensemble de pods.

Créer un fichier de définition de service :

Ouvrez un fichier nommé service.yaml :
```
nano service.yaml
```

Définir le service :

Ajoutez le contenu suivant :

apiVersion: v1
kind: Service
metadata:
  name: myservice
  namespace: mynamespace
spec:
  selector:
    app: myapp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

Enregistrez le fichier.

Appliquer le service :

Créez le service :
```
kubectl create -f service.yaml
```
Vérifier le service :

Vérifiez la liste des services :
```
kubectl get services -n mynamespace
```
Confirmez que myservice est listé.

Créer un secret

Les secrets (secrets) stockent de manière sécurisée des informations sensibles telles que des mots de passe ou des clés API.

Créer un fichier de définition de secret :

Ouvrez un fichier nommé secret.yaml :
```
nano secret.yaml
```

Définir le secret :

Ajoutez le contenu suivant avec des valeurs encodées en Base64 :

apiVersion: v1
kind: Secret
metadata:
  name: mysecret
  namespace: mynamespace
type: Opaque
data:
  username: dXNlcm5hbWU= ## Base64 for "username"
  password: cGFzc3dvcmQ= ## Base64 for "password"

Enregistrez le fichier.

Appliquer le secret :

Créez le secret :
```
kubectl create -f secret.yaml
```
Vérifier le secret :

Vérifiez la liste des secrets :
```
kubectl get secrets -n mynamespace
```
Confirmez que mysecret apparaît dans la sortie.

Créer un ConfigMap

Les ConfigMaps stockent des données de configuration sous forme de paires clé-valeur.

Créer un fichier de définition de ConfigMap :

Ouvrez un fichier nommé configmap.yaml :
```
nano configmap.yaml
```

Définir le ConfigMap :

Ajoutez le contenu suivant :

apiVersion: v1
kind: ConfigMap
metadata:
  name: myconfigmap
  namespace: mynamespace
data:
  database.host: "example.com"
  database.port: "5432"

Enregistrez le fichier.

Appliquer le ConfigMap :

Créez le ConfigMap :
```
kubectl create -f configmap.yaml
```
Vérifier le ConfigMap :

Vérifiez la liste des ConfigMaps :
```
kubectl get configmaps -n mynamespace
```
Confirmez que myconfigmap apparaît dans la sortie.

Résumé

Dans ce laboratoire, vous avez appris à :

Démarrer et vérifier un cluster Minikube.
Créer des ressources Kubernetes telles que des namespaces, des déploiements (deployments), des services (services), des secrets (secrets) et des ConfigMaps.
Vérifier l'état de ces ressources.

En maîtrisant ces étapes, vous serez en mesure de gérer et de déployer des applications efficacement sur Kubernetes. Entraînez-vous avec ces étapes pour renforcer votre compréhension!