alias k=kubectl sera déjà préconfiguré

export do="--dry-run=client -o yaml" # k créer un déploiement nginx --image=nginx $do

export now="--force --grace-period 0" # k supprimer le pod x $now

The provided text is a URL link and cannot be translated.

https://medium.com/bb-tutorials-and-thoughts/pratiquez-suffisamment avec ces questions pour l'examen CKAD-2f42d1228552

Créez un pod qui affiche ??bonjour le monde?? puis se termine. Faites en sorte que le pod soit supprimé automatiquement lorsque

c'est terminé

Lister les Pods avec nom et statut

Créer NS et avec pod dans l'espace de noms :

Obtenir un pod sans commande décrire.

Question de pod de l'ours affamé :

Créez et configurez le service front-end-services afin qu'il soit accessible via NodePort et qu'il redirige vers
le pod existant nommé front-end.

Créez un pod nginx montrant différents niveaux de verbosité :

Obtenir l'adresse IP du Pod

kubect1 obtenir des pods -o=jsonpath='{range

.items[*]}{.metadata.nom}{' '}{.status.podIP}{' '}{end}'
Image Busybox sommeil

Créer un nom de déploiement : nginx-aléatoire

Expose le déploiement avec le nom nginx-random
Les conteneurs au sein de tout pod exécuté dans le cadre de ce déploiement devraient utiliser nginx
Image

Ensuite, utilisez l'outil nslookup pour rechercher les enregistrements DNS du service et du pod et écrivez le
sortie vers /opt/KUNW00601/service.dns et /opt/KUNW00601/pod.dns respectivement.

Q1 Complété : sa, clusterrole, clusterrolebinding

Contexte -
Vous avez été invité à créer un nouveau ClusterRole pour un pipeline de déploiement et à le lier à un ServiceAccount spécifique à un
espace de noms spécifique.
Tâche -
Créez un nouveau ClusterRole nommé deployment-clusterrole, qui permet uniquement de créer les types de ressources suivants :
✑ Déploiement
✑ Set de Stateful
✑ DaemonSet
Créez un nouveau ServiceAccount nommé cicd-token dans l'espace de noms existant app-team1.
Liez le nouveau ClusterRole deployment-clusterrole au nouveau ServiceAccount cicd-token, limité au namespace app-team1.

Soleil :
Définir le contexte : kubectl config use-context k8s
kubectl créer le clusterrole deployment-clusterrole --verb=create --resource=Déploiement,Set d'états,DaemonSet
kubectl create sa cicd-token -n app-team1
kubectl créer un clusterrolebinding -n app-team1 --clusterrole=deployment-clusterrole --serviceaccount=app-team1:cicd-token
déployer-b

################################################################################################
####################################################
Q2 Drain terminé, non disponible
Tâche -
Définissez le nœud nommé ek8s-node-0 comme indisponible et replanifiez tous les pods qui s'exécutent dessus.
kubectl config utiliser-contexte ek8s

kubectl obtenir des nœuds

kubectl drain ek8s-node-1 --ignore-daemonsets --delete-emptydir-data # rendre indisponible

kubectl uncordon <nom du nœud> # le rendre de nouveau disponible
kubectl obtenir les nœuds et le nœud devrait être indisponible

################################################################################################
####################################################
Q3 : Mise à niveau terminée de tous les plans de contrôle et nœuds

Tâche -
Étant donné un cluster Kubernetes existant exécutant la version 1.22.1, mettez à jour tous les composants du plan de contrôle et des nœuds de Kubernetes.
sur le nœud master uniquement à la version 1.22.2.
Assurez-vous de vider le nœud principal avant de le mettre à niveau et décordonnez-le après la mise à niveau.
Vous êtes également censé mettre à niveau kubelet et kubectl sur le nœud maître.

définir le contexte : kubectl config utiliser-contexte mk8s

kubectl obtenir les nœuds

Drainez d'abord le nœud maître : kubectl drain mk8s-master-0 --ignore-daemonsets

vérifier l'état des nœuds : kubectl get nodes
SSH sur le nœud : ssh mk8s-master-0
sudo -i
apt install kubeadm=1.22.2-00 kubelet=1.22.2-00 kubectl=1.22.2-00
kubeadm mise à niveau plan
kubeadm upgrade appliquer v1.22.2
systemctl redémarrer kubelet
quitter ssh
kubectl uncordon mk8s-maître-0
kubectl get nodes pour vérifier la version
étapes:1

Étape 2 : Installer le composant

Étape 3 : exécutez à nouveau la même commande.

Étape 4 :

Étape 5 :

Étape 6 : si on a dit de joindre les nœuds

Étape 7 : redémarrer le processus

Étape 8 : déconnecter le nœud et vérifier la version

################################################################################################
####################################################

Q4 : Sauvegarde et restauration terminées

Q4 : kubectl config utiliser-contexte mk8s

Étape 1 : Cela créera un instantané à

Étape 2 : Ensuite, allez dans /var/lib/backup/etcd-snapshot.db et vérifiez si le fichier est présent ou non.
Recherchez également etcd-snapshort-previous.db
Étape 3 : arrêter le composant du plan de contrôle :

Sauvegarde Etcd
kubectl config contexte-utilisateur k8s-c3-CCC

créer une sauvegarde et l'enregistrer /tmp/etcd-backup.db

toucher 25.yaml
copier la commande de la documentation dans le fichier yaml

ETCDCTL_API=3 etcdctl --endpoints=https://[127.0.0.1]:2379 --cacert=/etc/kubernetes/pki/etcd/ca.crt \

/etc/kubernetes/pki/etcd/server.crt
instantané enregistrer /tmp/etcd-backup.db

k obtenir des pods -n kube-system

ssh cluster3-maître1
cat /etc/kuber*/manifest*/etcd.yaml | grep -i fichier # vérifier l'emplacement du serveur et du fichier cert, du fichier ca, du fichier clé

Exécutez la commande : dans le cluster et assurez-vous que vous êtes en ssh

ETCDCTL_API=3 etcdctl --endpoints=https://[127.0.0.1]:2379 --cacert=/etc/kubernetes/pki/etcd/ca.crt \
/etc/kubernetes/pki/etcd/server.crt
capture d'écran enregistrer /tmp/etcd-backup.db

vérifiez l'emplacement du fichier et le fichier de base de données en tant que sauvegarde prise

créer un pod dans le cluster : pour tester la sauvegarde

k run test --image=nginx --command sleep 1j

k obtenir des pods

k obtenir les pods -n kube-system | grep wc -l

Restaurer la sauvegarde et s'assurer que le cluster fonctionne toujours

ETCDCTL_API=3 etcdctl --endpoints=https://[127.0.0.1]:2379 --cacert=/etc/kubernetes/pki/etcd/ca.crt \

--cert=/etc/kubernetes/pki/etcd/server.crt --key=/etc/kubernetes/pki/etcd/server.key \
restaurer l'instantané /tmp/etcd-backup.db --répertoire-des-données=/var/lib/etcd-backup-1

cd /var/lib/etcd
ls -lrt

mettez à jour le fichier vi /etc/kub*/mani*/etcd.yaml

mettre à jour le paramètre volumes --> chemin hôte : Chemin : /var/lib/etcd-backup-1
k obtenir des pods -A

k obtenir tout -AC

Cela va arrêter ou suspendre le système pour effectuer une sauvegarde de la base de données et recréer le cluster.

k obtenir des pods -A

k get pods -n kube-system --no-headers | wc -l

##############################################################################################

Q5 : Politique réseau complétée

Tâche -
Créez une nouvelle NetworkPolicy nommée allow-port-from-namespace dans le namespace existant fubar.
Assurez-vous que la nouvelle NetworkPolicy permet aux Pods dans l'espace de noms interne de se connecter au port 9000 des Pods dans l'espace de noms fubar.
Assurez-vous également que la nouvelle NetworkPolicy :

✑ n'autorise pas l'accès aux Pods qui n'écoutent pas sur le port 9000
✑ n'autorise pas l'accès depuis les Pods qui ne sont pas dans l'espace de noms interne
Réponse :
définir le contexte : kubectl config utiliser le contexte hk8s

versionApi: networking.k8s.io/v1
NetworkPolicy

autoriser-port-de-nom-namespace # mettre à jour le nom

espace de noms : fubar #mettre à jour ns

spec
podSelector: {}
policyTypes
Ingress
entrée
- de :
namespaceSelector
matchLabels
mon-appli mettre à jour le nom

ports
- protocole : TCP
port : 9000
Enregistrer le fichier

kubectl label ns my-app prohject=my-app

kubectl décrire ns mon-application
kubectl créer -f policy.yaml
###############################################################################################
Q6 Service d'exposition complété
Tâche
Reconfigurer le front-end de déploiement existant et ajouter une spécification de port nommée http exposant le port 80/tcp de l'existant.
conteneur nginx.
Créez un nouveau service nommé front-end-svc exposant le port conteneur http.
Configurez le nouveau service pour exposer également les Pods individuels via un NodePort sur les nœuds sur lesquels ils sont programmés.

Répondre : kubectl config use-context k8s

kubectl obtenir déploiements.apps
kubectl modifier déploiement.app front-end
--> mettre à jour la spécification du port pour exporter 80 tcp
kubectl expose deployment front-end --name=front-end-svc --port=80 --type=NodePort --protocol=TCP

###############################################################################################
Q7 : Déploiement de scalee terminé 3
Tâche -
Élever la présentation de déploiement à 3 pods.

Répondre : kubectl config use-context k8s

kubectl obtenir déploiements.applications

kubectl échelonner le déploiement de présentation --réplicas=3

kubectl obtenir pod

###############################################################################################
Q8 : Sélecteur de nœud complété disque : ssd
Tâche -
Planifiez un pod comme suit :
✑ nginx-kusc00401
✑ Image : nginx
✑ Sélecteur de nœud : disque=ssd
Définir le contexte : kubectl config use-context k8s
k run nginx-kusc00401 --image=nginx --dry-run=client -o yaml > 8.yaml
vi 8.yaml
versionApi: v1
Pod
metadata:
labels
exécuter : nginx-kusc00401
nginx-kusc00401
spécification
conteneurs
nginx
nginx-kusc00401
nodeSelector
ssd
kubectl create -f 7.yaml
kubectl obtenir des pods

###############################################################################################
Q9 : De nombreux nœuds complétés

Tâche -
Vérifiez combien de nœuds sont prêts (sans inclure les nœuds teintés NoSchedule) et
écrire le numéro dans /opt/KUSC00402/kusc00402.txt.

Définir le contexte : kubectl config use-context k8s

kubectl obtenir des nœuds

kubectl get nodes -o jsonpath="{range .items[*]}{.metadata.name} {.spec.taints[?(@.effect=='NoSchedule')].effect}{\n}{end}"

echo "3" > /opt/KUSC00402/kusc00402.txt

chat /opt/KUSC00402/kusc00402.txt
###############################################################################################
Q10 : 2 conteneurs complétés
Planifiez un Pod comme suit :
✑ kucc8
✑ Conteneurs d'applications : 2
✑ Nom/Images du conteneur :
- nginx
consul

définir le contexte : kubectl config use-context k8s

kubectl run kucc8 --image=nginx --dry-run=client -o yaml > 10.yaml
vi 10.yaml et ajoutez le nom du 2ème conteneur et le nom de l'image

versionApi: v1
Pod

labels
exécuter : kucc8

kucc8
spec
conteneurs
nginx
nginx
consul
consul
##############################################################################################
Q11 : Volume persistant complété
Tâche -
Créez un volume persistant nommé app-data, d'une capacité de 2Gi et
mode d'accès ReadOnlyMany.
Le type de volume est hostPath et son emplacement est /srv/app-data.

définir le contexte : kubectl config utiliser-le-contexte hk8s

voir le document de volume persistant et obtenir le fichier yaml et mettre à jour les valeurs ci-dessous

type: VolumePersistant
versionApi: v1

données-app
spec
capacité
2Go
accessModes
LectureSeulementMultiples

hostPath
/srv/app-data

kubectl obtenir pv
kubeclt créer -f 11.yaml
kubectl get pv # vérifiez la même chose
###############################################################################################
Q12 : Journaux d'erreurs complétés

Tâche -
Surveiller les journaux du pod foo et :
✑ Extraire les lignes de journal correspondant à l'erreur fichier introuvable
✑ Écrivez-les dans /opt/KUTR00101/foo

définir le contexte : kubectl config utiliser-contexte k8s

kubectl obtenir des pods foo

kubectl logs foo

kubectl logs foo | grep -i "fichier-introuvable" > /opt/KUTR00101/foo
cat /opt/KUTR00101/foo # pour vérifier cela

###############################################################################################
Conteneur sidecar complété
Contexte -
Un Pod existant doit être intégré à l'architecture de journalisation intégrée de Kubernetes (par exemple, kubectl logs).
Ajouter un conteneur sidecar de streaming est une bonne et courante façon d'accomplir cette exigence.

Tâche -
Ajoutez un conteneur sidecar nommé sidecar, en utilisant l'image busybox, au Pod existant big-corp-app.
Le nouveau conteneur de sidecar doit exécuter la commande suivante :

Utilisez un volume, monté à /var/log, pour rendre le fichier journal big-corp-app.log disponible au conteneur sidecar.

Répondre :
définir le contexte : kubectl config utiliser-contexte k8s

kubectl get pods -A

kubectl obtenir des pods Big-corp-app -o yaml > 13.yaml
éditez le vi 13.yaml
ajoutez ce qui suit dedans

spec
volumes
journaux
conteneurs
busybox
sidecar
commande: ["/bin/sh"]
args: ["-c", "tail -n+1 -f /var/log/big-corp-app.log"]
volumeMounts
journaux
/var/log

enregistrer le fichier et recréer le pod et vérifier le pod

kubectl créer -f remplacer file.yaml
kubectl obtenir pod
###############################################################################################
Q14 : Charges de travail CPU élevées terminées

Tâche -
À partir de l'étiquette de pod nom=overloaded-cpu, trouvez les pods exécutant des charges de travail CPU élevées et

écrire le nom du pod consommant le plus de CPU dans le fichier /opt/KUTR00401/KUTR00401.txt (qui existe déjà).

Répondre :
définir le contexte : kubectl config use-context k8s
kubectl obtenir des pods -A

kubectl top pods

kubectl top pods -l name=overloaded-cpu --sort-by=cpu
echo "processeur-surchargé-1234" > /opt/KUTR00401/KUTR00401.txt
chat /opt/KUTR00401/KUTR00401.txt
###############################################################################################
Q15 : Correction du kubelet terminée, pas prête

Tâche -
Un nœud de travail Kubernetes, nommé wk8s-node-0 est dans l'état NotReady.
Investiguer pourquoi c'est le cas et effectuer les étapes appropriées pour ramener le nœud à un état Prêt.
s'assurant que toutes les modifications soient permanentes.

Répondre :
configurer le contexte : kubectl configurer utiliser le contexte wk8s

kubectl obtenir des nœuds

kubectl décrire nœuds wk8s-node-0

ssh wk8s-nœud-0
sudo -i
systemctl status kubelet
systemctl redémarrer kubelet
systemctl démarrer kubelet
sortie
kubectl obtenir nœud
###############################################################################################
Réclamation complétée
Tâche -
Créez un nouveau PersistentVolumeClaim :
✑ volume-pv
✑ Classe : csi-hostpath-sc
✑ Capacité : 10 Mo

Créez un nouveau Pod qui monte le PersistentVolumeClaim en tant que volume :

✑ serveur-web
✑ Image : nginx
✑ Chemin de montage : /usr/share/nginx/html

Configurez le nouveau Pod pour avoir un accès ReadWriteOnce sur le volume.

Enfin, en utilisant kubectl edit ou kubectl patch, augmentez le PersistentVolumeClaim à une capacité de 70Mi et enregistrez ce changement.

Répondre :
configurer le contexte : kubectl configurer utiliser-contexte ok8s

v1
RequêteDeVolumePersistant

volume-pv
spécification
accessModes
ReadWriteOnce
ressources
requests
10Mo
csi-hostpath-sc
enregistrer le fichier 16-pvc.yaml et

kubeclt créer -f 16-pvc.yaml

kubectl get pv,pvc # vérifier que le pvc a une capacité de 10Mi

Revendication en volume :

v1
Pod

serveur-web Mettre à jour le nom du pod

spécification
conteneurs
serveur-web # mettre à jour le nom du conteneur

nginx mettre à jour le nom de l'image

volumeMounts
/usr/share/nginx/html # mettre à jour le chemin

stockage-pv-tâche
volumes
tâche-pv-stockage # mettre à jour le nom

persistentVolumeClaim
volume-pv # mettre à jour le nom

enregistrer le fichier et l'exécuter

kubectl créer -f 16pod.yaml

kubectl obtenir des pods -o large
3) kubectl edit PersistentVolumeClaim/pv-volume
pour cela, exécutez kubectl get pvc pv-volume -o yaml > 16.yaml
mettre à jour la capacité de 10 à 70Mi dans un nouveau fichier yaml
enregistrer le fichier et vérifier à nouveau le PVC

kubectl remplacer -f updatepvc.yaml

kubectl get pvc pour vérifier la capacité de 10 à 70
###############################################################################################
Ingress terminé
Tâche
Créez une nouvelle ressource Ingress nginx comme suit :
✑ pong
✑ Espace de noms : ing-interne
✑ Exposition du service hello sur le chemin /hello en utilisant le port de service 5678

Répondre :
définir le contexte : kubectl config utiliser-contexte k8s
vérifiez le document et recherchez la ressource Nginx Ingress
La ressource Ingress
vi 17.yaml

apiVersion: networking.k8s.io/v1
Ingress

pong
ing-interne
annotations
nginx.ingress.kubernetes.io/rewrite-target: /
spécifications
règles :
- http:
chemins
/bonjour
Préfixe
arrière-plan
service
bonjour
port
5678
enregistrer le fichier et exécuter le fichier

kubectl créer -f 17.yaml

kubectl obtenir ingress -n ing-interne
vérifiez le service : curl -kL IPAddress/hello # pour vérifier le même
################################################################################################
####################################################
Q18
Créez un nouveau compte de service avec le nom pvviewer.
Accorder à ce compte de service l'accès pour lister tous les PersistentVolumes dans le cluster par
Créer un rôle de cluster approprié appelé pvviewer-role et
ClusterRoleBinding appelé pvviewer-role-binding.
Ensuite, créez un pod appelé pvviewer avec l'image : redis et le compte de service : pvviewer dans le namespace par défaut.

Répondre :
kubectl créer sa pvviewer
kubectl créer un clusterrole pvviewer-role --verb=create --resource=PersistentVolumes
kubectl créer un lien de rôle de cluster pvviewer-role-binding --clusterrole=pvviewer-role --serviceaccount=default:pvviewer

vérifiez-le :
kubectl auth can-i list PersistentVolumes -as system:serviceaccount:default:pvviewer

créer un pod
kubectl run pvviewer --image=redis -n par défaut

versionApi: v1
Pod
translatedText
labels
exécuter : pvviewer

pvviewer
spéc
conteneurs
redis
pvviewer
pvviewer

enregistrer le fichier yaml et créer un pod

kubectl créer -f 18.yaml

###############################################################################################
Q19
Créez un nouveau déploiement appelé nginx-deploy, avec l'image nginx:1.16 et 1 réplique.
Enregistrez la version. Ensuite, mettez à niveau le déploiement vers la version 1.17 en utilisant la mise à jour progressive.

Assurez-vous que la mise à niveau de la version soit enregistrée dans l'annotation des ressources.

obtenir le fichier yaml à partir du document

kubectl créer déploiement nginx-deploy --image=nginx:1.16 --répliques=1 --simulation=client -o yaml > 19.yaml
apiVersion: apps/v1
Déploiement

creationTimestamp: null
étiquettes
nginx-déploy
déploiement-nginx
spécification
replicas: 1
sélecteur
matchLabels
déploiement-nginx
strategy: {}
modèle
métadonnées
creationTimestamp: null
étiquettes
nginx-deploy
spec
conteneurs
nginx:1.16
nginx
resources: {}
status: {}
# Mettez à jour le fichier yaml comme ci-dessous :

apiVersion: apps/v1
Déploiement

étiquettes
déploiement-nginx
déploiement-nginx
spéc
replicas: 1
selector
matchLabels
déploiement-nginx
modèle

labels
nginx-déployer
spec
conteneurs
nginx:1.16
nginx-déployer
ports
- containerPort: 80

enregistrer le fichier 19.yaml

kubectl apply -f nginx-deployment.yaml --record

kubectl obtenir déploiement
kubectl rollout history déploiement nginx-deploy
déploiement.apps/nginx-deploy
MODIFICATION DE RÉVISION - CAUSE

1 kubectl apply --filename=19.yaml --record=true

kubectl set image deployment.apps/nginx-deploy nginx-deploy=1.17 --record

kubectl décrire le déploiement nginx-deploy
déploiement.apps/nginx-deploy
CHANGEMENT DE RÉVISION - CAUSE

1 kubectl set image deployment.apps/nginx-deploy nginx=1.17 --record=true

2 kubectl mettre à jour l'image déploiement.apps/nginx-deploy nginx-deploy=1.17 --enregistrer=true

plan de contrôle $
###############################################################################################
Q20
Créer un Pod appelé non-root-pod, image : redis:alpine
1000
fsGroup: 2000

apiVersion: v1
Pod

étiquettes
pod-non-root
spécification
securityContext
runAsUser: 1000
fsGroup: 2000
conteneurs
redis:alpine
pod-non-root
###############################################################################################
Q21
Créez une NetworkPolicy qui refuse tout le trafic entrant
apiVersion: networking.k8s.io/v1
PolitiqueRéseau

refuser-par-défaut-tout-entrant
spécification
podSelector: {}
policyTypes
Ingress

kubectl appliquer -f 21.yaml

kubectl obtenir des politiques de réseau.networking.k8s.io

Créez une NetworkPolicy qui nie tout le trafic Egress

versionApi: mise en réseau.k8s.io/v1

Politique de Réseau

refuser-par-défaut-tout-sortie
spec
podSelector: {}
policyTypes
Sortie

kubectl décrire les politiques de réseau.networking.k8s.io défaut-interdire-tout-ingre

kubectl décrire politiques de réseau.networking.k8s.io default-deny-all-egress

Context -
Vous avez été chargé de créer un nouveau ClusterRole pour un pipeline de déploiement et de le lier à un ServiceAccount spécifique limité à un
espace de noms spécifique.

Tâche -
Créez un nouveau ClusterRole nommé deployment-clusterrole, qui ne permet que de créer les types de ressources suivants :
✑ Déploiement
✑ Set Stateful
✑ DaemonSet
Créez un nouveau ServiceAccount nommé cicd-token dans le namespace existant app-team1.
Lier le nouveau ClusterRole deployment-clusterrole au nouveau ServiceAccount cicd-token, limité au namespace app-team1.

alias k=kubectl # sera déjà préconfiguré

export do="--dry-run=client -o yaml" # k create deploy nginx --image=nginx $do
export maintenant="--force --grace-period 0" # k supprimer pod x $maintenant

T1
Contexte -
Vous avez été invité à créer un nouveau ClusterRole pour un pipeline de déploiement et à l'associer à un ServiceAccount spécifique limité à un domaine spécifique.
espace de noms.

Tâche -
Créez un nouveau ClusterRole nommé deployment-clusterrole, qui permet uniquement de créer les types de ressources suivants :
✑ Déploiement
✑ Ensemble avec état
✑ DémonSet
Créez un nouveau ServiceAccount nommé cicd-token dans le namespace existant app-team1.
Liez le nouveau ClusterRole deployment-clusterrole au nouveau ServiceAccount cicd-token, limité au namespace app-team1.

Solution :
Définir le contexte : kubectl config utiliser-contexte k8s
kubectl créer le clusterrole deployment-clusterrole --verb=create --resource=Deployment,StatefulSet,DaemonSet
kubectl créer sa cicd-token -n app-team1
kubectl créer un clusterrolebinding -n app-team1 --clusterrole=deployment-clusterrole --serviceaccount=app-team1:cicd-token deploy-b

#################################################################################################################
T2
Tâche -
Définissez le nœud nommé ek8s-node-0 comme indisponible et reprogrammez tous les pods qui y fonctionnent.
kubectl configuer contexte ek8s

kubectl obtenir des nœuds

kubectl drain ek8s-node-1 --ignore-daemonsets --delete-emptydir-data # rendre indisponible
kubectl uncordon <nom du nœud> # le rendre à nouveau disponible
kubectl obtenir des nœuds et le nœud devrait être indisponible
#################################################################################################################
Q3
Tâche -
Étant donné un cluster Kubernetes existant fonctionnant sous la version 1.22.1, mettre à niveau tous les composants du plan de contrôle Kubernetes et des nœuds.
nœud maître uniquement à la version 1.22.2.
Assurez-vous de vider le nœud maître avant de le mettre à niveau et de le débloquer après la mise à niveau.
Vous êtes également censé mettre à niveau kubelet et kubectl sur le nœud maître.

définir le contexte : kubectl config utiliser-contexte mk8s

kubectl obtenir des nœuds
Tout d'abord, vider le nœud maître : kubectl drain mk8s-master-0 --ignore-daemonsets
vérifier l'état du nœud : kubectl get nodes
ssh dans le nœud : ssh mk8s-master-0
sudo -i
apt install kubeadm=1.22.2-00 kubelet=1.22.2-00 kubectl=1.22.2-00
kubeadm mise à niveau plan
kubeadm mise à niveau appliquer v1.22.2
systemctl redémarrer kubelet
sortir de ssh
kubectl uncordon mk8s-master-0
kubectl get nodes pour vérifier la version
#################################################################################################################
Q4 : kubectl config utiliser-contexte mk8s

Sauvegarde Etcd
kubectl config user-context k8s-c3-CCC

créer une sauvegarde et l'enregistrer /tmp/etcd-backup.db

touch 25.yaml
copier la commande de la documentation dans le fichier yaml

ETCDCTL_API=3 etcdctl --endpoints=htps:///122.0.0.11:2327 --cacert=/etc/kubernetes/pki/etcd/ca.crt \

--cert=/etc/kubernetes/pki/etcd/server.crt --key=/etc/kubernetes/pki/etcd/server.key \
instantané enregistrer /tmp/etcd-backup.db

k obtenir des pods -n kube-system

ssh cluster3-maître1
cat /etc/kuber*/manifest*/etcd.yaml | grep -i fichier # vérifier l'emplacement du serveur et des fichiers cert, ca, clé

Exécutez la commande : dans le cluster et assurez-vous que vous êtes en ssh

ETCDCTL_API=3 etcdctl --endpoints=htps:///122.0.0.11:2327 --cacert=/etc/kubernetes/pki/etcd/ca.crt \
/etc/kubernetes/pki/etcd/server.crt
instantané sauvegarde /tmp/etcd-backup.db

vérifiez l'emplacement du fichier et le fichier de base de données en tant que sauvegarde prise

créer un pod dans le cluster : pour tester la sauvegarde

k run test --image=nginx --command sleep 1j

k obtenir des pods

k obtenir des pods -n kube-system | grep wc -l

Restaurez la sauvegarde et assurez-vous que le cluster fonctionne toujours.

ETCDCTL_API=3 etcdctl --endpoints=htps:///122.0.0.11:2327 --cacert=/etc/kubernetes/pki/etcd/ca.crt \

--cert=/etc/kubernetes/pki/etcd/server.crt --key=/etc/kubernetes/pki/etcd/server.key \
restaurer l'instantané /tmp/etcd-backup.db --dossier-des-données=/var/lib/etcd-backup-1

cd /var/lib/etcd
ls -lrt
mettez à jour le fichier vi /etc/kub*/mani*/etcd.yaml
mettre à jour le paramètre volumes --> chemin hôte : Chemin : /var/lib/etcd-backup-1
k obtenir des pods -A
k obtenir tout -AC
Cela arrêtera ou suspendra le système pour effectuer la sauvegarde de la base de données et la recréation du cluster.
k obtenir des pods -A
k obtenir les pods -n kube-system --sans-en-têtes | wc -l
#################################################################################################################
Q5
Tâche -
Créez une nouvelle NetworkPolicy nommée allow-port-from-namespace dans le namespace existant fubar.
Assurez-vous que la nouvelle NetworkPolicy permet aux pods dans le namespace interne de se connecter au port 7000 des pods dans le namespace fubar.
Veillez également à ce que la nouvelle politique réseau :
✑ n'autorise pas l'accès aux Pods qui n'écoutent pas sur le port 7000
✑ n'autorise pas l'accès depuis des Pods qui ne sont pas dans l'espace de noms interne

Réponse :
définir le contexte : kubectl config utiliser-contexte hk8s

versionApi : mise en réseau.k8s.io/v1

NetworkPolicy

autoriser-port-de-namespace # mettre à jour le nom

fubar #mise à jour ns

spec
podSelector: {}
policyTypes
Infiltration
ingress
from
namespaceSelector
matchLabels
mon-app # mise à jour du nom

ports
TCP
port: 7000
Sauvegarder le fichier

kubectl label ns my-app prohject=my-app

kubectl décrire ns mon-app
kubectl create -f policy.yaml
#################################################################################################################
Q6 :
Tâche -
Reconfigurez le déploiement existant du front-end et ajoutez une spécification de port nommée htp exposant le port 80/tcp du conteneur existant.
nginx
Créez un nouveau service nommé front-end-svc exposant le port de conteneur htp.
Configurez le nouveau service pour exposer également les Pods individuels via un NodePort sur les nœuds sur lesquels ils sont planifiés.

Réponse : kubectl config utiliser-contexte k8s

kubectl obtenir des déploiements.apps
kubectl modifier déploiement.app front-end
--> mettre à jour la spécification du port pour exporter 80 tcp

kubectl expose deployment front-end --name front-end-svc --port=80 --type=NodePort --protocol=TCP

#################################################################################################################
Q2
Tâche -
Mettez à l'échelle la présentation de déploiement à 3 pods.

Répondre : kubectl configurer le contexte k8s

kubectl obtenir des déploiements.apps
kubectl scale deployment presentaton --replicas=3
kubectl obtenir pod
#################################################################################################################
Q8
Tâche -
Planifiez un pod comme suit :
✑ nginx-kusc00401
✑ Image : nginx
✑ Sélecteur de nœuds : disque=ssd

Configurer le contexte : kubectl config utiliser-contexte k8s

k run nginx-kusc00401 --image=nginx --dry-run=client -o yaml >2.yaml

vi2.yaml

versionApi: v1
Pod
métadonnées :
étiquettes
exécuter : nginx-kusc00401
nginx-kusc00401
spéc
conteneurs
nginx
nginx-kusc00401
nodeSelector
ssd

kubectl créer -f2.yaml

kubectl obtenir des pods

#################################################################################################################
Q7
Tâche -
Vérifiez combien de nœuds sont prêts (sans inclure les nœuds marqués NoSchedule) et
écrivez le nombre dans /opt/KUSC00402/kusc00402.txt.

Configurer le contexte : kubectl config use-context k8s

kubectl obtenir les nœuds
kubectl obtenir nœuds -o jsonpath="{plage .articles[*]}{.métadonnées.nom} {.spéc.outrages[?(@.effet=='NoSchedule')].effet}{" "}{fin}"

echo "3" > /opt/KUSC00402/kusc00402.txt

cat /opt/KUSC00402/kusc00402.txt
#################################################################################################################
Q10 :
Planifiez un Pod comme suit :
✑ kucc8
✑ Conteneurs d'application : 2
✑ Nom de conteneur/Images :
nginx
consul

définir le contexte : kubectl config utiliser-contexte k8s

kubectl run kucc8 --image=nginx --dry-run=client -o yaml > 10.yaml
vi 10.yaml et ajoutez le nom du 2ème conteneur et le nom de l'image
apiVersion: v1
Pod

étiquettes
exécuter : kucc8

kucc8
spéc
conteneurs
nginx
nginx
consul
consul
#################################################################################################################
Q11 :
Tâche -
Créer un volume persistant nommé app-data, d'une capacité de 2Gi et
mode d'accès ReadOnlyMany.
Le type de volume est hostPath et son emplacement est /srv/app-data.
définir le contexte : kubectl config utiliser-contexte hk8s
voir le document de volume persistant et obtenir le fichier yaml et mettre à jour les valeurs ci-dessous

VolumePersistance
versionApi: v1

données-app
spécifications
capacité
2Gi
accessModes
LectureSeuleMultiple
chemin hôte
/srv/app-données

kubectl obtenir pv
kubeclt créer -f 11.yaml
kubectl get pv # vérifier la même chose
#################################################################################################################
Q12
Tâche -
Surveillez les journaux du pod foo et :
✑ Extraire les lignes de journal correspondant à l'erreur fichier introuvable
✑ Écrivez-les dans /opt/KUTR00101/foo

définir le contexte : kubectl config utiliser-contexte k8s

kubectl obtenir des pods foo

kubectl logs foo
kubectl logs foo | grep -i "fichier introuvable" > /opt/KUTR00101/foo
cat /opt/KUTR00101/foo # pour le vérifier
#################################################################################################################
Q13
Contexte -
Un Pod existant doit être intégré dans l'architecture de journalisation intégrée de Kubernetes (par exemple, kubectl logs).
Ajouter un conteneur sidecar de streaming est une bonne et courante manière d'accomplir cette exigence.

Tâche -
Ajoutez un conteneur sidecar nommé sidecar, en utilisant l'image busybox, au Pod existant big-corp-app.
Le nouveau conteneur de sidecar doit exécuter la commande suivante :

Utilisez un volume, monté à /var/log, pour rendre le fichier journal big-corp-app.log disponible au conteneur sidecar.

Répondre :
définir le contexte : kubectl config utiliser-le-contexte k8s
kubectl obtenir des pods -A
kubectl obtenir les pods Big-corp-app -o yaml > 13.yaml
éditez le vi 13.yaml
ajoutez ce qui suit dedans

spec
volumes
journaux
conteneurs
busybox
sidecar
commande: ["/bin/sh"]
args: ["-c", "tail -n+1 -f /var/log/big-corp-app.log"]
volumeMounts
journaux
/var/log

enregistrer le fichier et recréer le pod et vérifier le pod

kubectl create -f remplacer fichier.yaml
kubectl obtenir pod
#################################################################################################################
Q14
Tâche -
À partir de l'étiquette du pod nom=cpu-surchargé, trouvez les pods qui exécutent des charges de travail à forte intensité CPU et

écrire le nom du pod consommant le plus de CPU dans le fichier /opt/KUTR00401/KUTR00401.txt (qui existe déjà).

Répondre :
définir le contexte : kubectl config use-context k8s
kubectl obtenir pods -A
kubectl top pods
kubectl top pods -l nom=cpu-surcharge --trier-par=cpu
echo "processeur-surchargé-1234" > /opt/KUTR00401/KUTR00401.txt
chat /opt/KUTR00401/KUTR00401.txt
#################################################################################################################
Q15
Tâche -
Un nœud de travail Kubernetes, nommé wk8s-node-0, est en état NotReady.
Enquêtez sur les raisons de cela et effectuez les démarches appropriées pour amener le nœud à un état Prêt.
assurant que tout changement soit permanent.

Répondre :
définir le contexte : kubectl config utiliser le contexte wk8s
kubectl obtenir les nœuds
kubectl décrire nœuds wk8s-node-0
ssh wk8s-noeud-0
sudo -i
systemctl statut kubelet
systemctl redémarrer kubelet
systemctl démarrer kubelet
sortie
kubectl obtenir nœud
#################################################################################################################
Q16
Tâche -
Créer un nouveau PersistentVolumeClaim :
✑ volume-pv
✑ Classe : csi-hostpath-sc
✑ Capacité : 10Mo

Créez un nouveau Pod qui monte le PersistentVolumeClaim en tant que volume :

✑ serveur web
✑ Image : nginx
✑ Chemin de montage : /usr/share/nginx/html

Configurez le nouveau Pod pour avoir un accès ReadWriteOnce sur le volume.

Enfin, en utilisant kubectl edit ou kubectl patch, étendez le PersistentVolumeClaim à une capacité de 20Mo et enregistrez ce changement.

Répondre :
définir le contexte : kubectl config utiliser-contexte ok8s

versionApi: v1
PersistentVolumeClaim

pv-volume
spécifications
accessModes
ReadWriteOnce
ressources
requests
10Mi
csi-hostpath-sc

sauvegarder le fichier 16-pvc.yaml et

kubeclt créer -f 16-pvc.yaml

kubectl obtenir pv,pvc vérifiez le PVC ayant une capacité de 10 Mi
Revendiquer en volume :

v1
Pod
metadata:
serveur web mettez à jour le nom de la pod

spec
conteneurs
serveur-web # mettre à jour le nom du conteneur
nginx # mettre à jour le nom de l'image

volumeMounts
/usr/share/nginx/html # mettre à jour le chemin

stockage-pv-tâche
volumes
tâche-pv-stockage # mettre à jour le nom

persistentVolumeClaim
volume-pv mettre à jour le nom

sauvegarder le fichier et l'exécuter

kubectl créer -f 16pod.yaml

kubectl get pods -o large

3) kubectl éditer PersistentVolumeClaim/pv-volume

pour cela, exécutez kubectl get pvc pv-volume -o yaml > 16.yaml
mettre à jour la capacité de 10 à 20 Mi dans un nouveau fichier yaml
enregistrer le fichier et vérifier à nouveau le pvc

kubectl remplacer -f updatepvc.yaml

kubectl get pvc pour vérifier la capacité de 10 à 20
#################################################################################################################
Q12
Tâche -
Créez une nouvelle ressource Ingress nginx comme suit :
✑ pong
✑ Espace de noms : ing-interne
✑ Exposition du service hello sur le chemin /hello en utilisant le port de service 5628

Répondre :
définir le contexte : kubectl config utiliser-contexte k8s
vérifiez le document et recherchez la ressource Ingress nginx
La ressource Ingress
vi 12.yaml

apiVersion: networking.k8s.io/v1
Ingress

pong
espace_de_noms: ing-interne
annotatons
nginx.ingress.kubernetes.io/rewrite-target: /
spéc
règles
htp
chemins
/bonjour
Préfixe
backend
service
bonjour
port
number: 5628

enregistrer le fichier et exécuter le fichier

kubectl créer -f 12.yaml

kubectl obtenir ingress -n ing-internal
vérifiez le service : curl -kL IPAddress/hello # pour vérifier la même chose
#################################################################################################################
Q18
Créez un nouveau compte de service avec le nom pvviewer.
Accorder à ce compte de service l'accès pour lister tous les PersistentVolumes dans le cluster par
création d'un rôle de cluster approprié appelé pvviewer-role et
ClusterRoleBinding appelé pvviewer-role-binding.
Ensuite, créez un pod appelé pvviewer avec l'image : redis et le compte de service : pvviewer dans le namespace par défaut.

Répondre :
kubectl create sa pvviewer
kubectl créer un clusterrole pvviewer-role --verb=create --resource=PersistentVolumes
kubectl créer un lien de rôle de cluster pvviewer-role-binding --clusterrole=pvviewer-role --serviceaccount=default:pvviewer

vérifiez-le :
kubectl auth can-i lister PersistentVolumes --as system:serviceaccount:default:pvviewer

créer un pod
kubectl run pvviewer --image=redis -n par défaut

v1
Pod

labels
exécuter : pvviewer
pvviewer
spéc
conteneurs
redis
pvviewer
pvviewer

enregistrer le fichier yaml et créer un pod

kubectl créer -f 18.yaml

#################################################################################################################
Q17
Create a new deployment called nginx-deploy, with image nginx:1.16 and 1 replica.
Enregistrez la version. Ensuite, mettez à niveau le déploiement vers la version 1.12 en utilisant une mise à jour progressive.
Assurez-vous que la mise à niveau de la version est enregistrée dans l'annotation des ressources.

Obtenez le fichier yaml via la commande ci-dessous :

kubectl créer un déploiement nginx-deploy --image=nginx:1.16 --replicas=1 --dry-run=client -o yaml > 17.yaml
versionApi: applications/v1
Déploiement

creatonTimestamp: null
labels
nginx-déployer
nginx-déployer
spécification
replicas: 1
selector
matchLabels
nginx-deploy
strategy: {}
modèle :

creatonTimestamp: null
étiquettes
nginx-déployer
spec
conteneurs
nginx:1.16
nginx
resources: {}
status: {}
# Mettez à jour le fichier yaml comme ci-dessous :

apiVersion: applications/v1
Déploiement
métadonnées
étiquettes
déployer-nginx
déploiement nginx
spec
replicas: 1
selector
matchLabels
nginx-déployer
modèle

étiquettes
nginx-deploy
spéc
conteneurs
nginx:1.16
nginx-déployer
ports
- containerPort: 80

enregistrer le fichier 17.yaml

kubectl apply -f nginx-deployment.yaml --record

kubectl obtenir le déploiement
kubectl rollout history deployment nginx-deploy
déploiement.apps/nginx-deploy
CHANGEMENT DE RÉVISION - CAUSE
1 kubectl apply --filename=17.yaml --record=true

kubectl définir l'image déploiement.apps/nginx-deploy nginx-deploy=1.12 --enregistrer

kubectl décrire déploiement nginx-deploy
déploiement.apps/nginx-deploy
CHANGEMENT DE RÉVISION - CAUSE
1 kubectl set image deployment.apps/nginx-déploy nginx=1.12 --record=true
2 kubectl set image déploiement.apps/nginx-deploy nginx-deploy=1.12 --record=true

plan de contrôle $
#################################################################################################################
Q20 :
Créer un pod appelé non-root-pod, image : redis:alpine
runAsUser: 1000
fsGroup: 2000

versionApi: v1
Pod
metadata:
labels
pod-non-root
spéc
securityContext
runAsUser: 1000
fsGroup: 2000
conteneurs
redis:alpine
pod-non-root
#################################################################################################################
Q21
Créez une politique de réseau qui refuse tout le trafic entrant

apiVersion: networking.k8s.io/v1
PolitiqueRéseau

refuser-tout-ingress-default
spec
podSelector: {}
policyTypes
Ingress
kubectl appliquer -f 21.yaml
kubectl obtenir des politiques de réseau.networking.k8s.io

Créer une NetworkPolicy qui interdit tout le trafic Egress

versionApi: mise_en_réseau.k8s.io/v1
type: PolitiqueRéseau
métadonnées
refuser-par-defaut-toute-sortie
spécifications
podSelector: {}
policyTypes
Sortie

kubectl décrire politiques de réseau.networking.k8s.io refus par défaut-tout-ingre

kubectl décrire networkpolicies.networking.k8s.io default-deny-all-egress

#################################################################################################################
Site Medium.com 50 questions

1. Créez un nouveau pod avec l'image nginx

k exécuter nginx --image=nginx

2. Créez un nouveau pod nommé redis avec l'image redis:1.77.

k exécuter redis --image=redis:1.77

3. Identifier le problème avec le pod.

k obtenir pod redis
k logs redis
k décrire le pod redis

4.Créez un nouveau replicaset rs-1

utilisation de l'image nginx avec

labelster:frontend et
sélecteurs aster:frontend.
Créez 3 répliques pour le même.

obtenir le fichier yaml à partir du document

versionApi: apps/v1
ReplicaSet

rs-1
étiquettes
nginx
frontend
spec
modifiez les réplicas selon votre cas
replicas: 3
sélecteur
matchLabels
frontend
modèle

labels
frontend
spécification
conteneurs
nginx
image: nginx

enregistrer le fichier et exécuter le fichier

kubectl create -f re.yaml

kubectl obtenir rs

5. Augmenter le replicaset ci-dessus à 5 réplicas

kubectl scale rs rs-1 --replicas=5
6. Mettez à jour l'image du replicaset ci-dessus pour utiliser l'image nginx:alpine.
modifiez le set de réplicas en utilisant kubectl edit rs rs-1 et mettez à jour le nom de l'image
enregistrer le fichier et vérifier le même

2. Augmentez le replicaset ci-dessus à 2 réplicas

kubectl échelle rs rs-1 -r-replicas=2

#################################################################################################################
reate three pods, pod name and their image name is given below:

Nom du Pod
nginx nginx
busybox1 busybox1, dormir 3600
busybox2 busybox2, dormir 1800
Assurez-vous que seul le pod busybox1 puisse communiquer avec le pod nginx sur le port 80.
le pod busybox2 ne devrait pas pouvoir se connecter au pod Nginx.

Répondre :
kubectl run nginx --image:nginx
kubectl run busybox1 --image:busybox1 --sleep 3600
kubectl run busybox2 --image:busybox2 --sleep 1800
kubectl obtenir des pods Cela devrait fonctionner

Créer une politique de réseau :

apiVersion: networking.k8s.io/v1
PolitiqueRéseau
métadonnées :
politique réseau
espace de noms : par défaut

spéc:
podSelector
matchLabels
exécuter : nginx

policyTypes
– Ingress
entrée
– de :
podSelector
matchLabels
exécuter : busybox1
ports
– protocole : TCP
port: 80
kubectl create -f networkpolicy.yaml
kubectl décrire politique réseau networkpolicy

faire valider

kubectl exec -it busybox1 — telnet 172.168.22.131 80 cela devrait être un succès
kubectl exec -it busybox2 — telnet 172.168.22.131 80 cela devrait échouer
#################################################################################################################
Des pods avec des limites strictes sur le CPU et la mémoire

Créer un pod "cka-pod" utilisant l'image "nginx", avec une limite stricte de 0,5 CPU et 20 Mi de mémoire dans l'espace de noms "cka-exam".

vérifiez si l'espace de noms est disponible ou non, sinon créez-le

kubectl créer ns cka-exam
k run cks-pod --image=nginx --dry-run=client -n cka-exam -o yaml > question.yaml
mettre à jour les limites de fichiers et de ressources

apiVersion: v1
Pod

cka-pod
cka-examen
spécification
conteneurs
cka-pod
nginx
 ressources
limites
0,5
20Mo

kubectl créer -f resource-limit.yaml

#################################################################################################################

#################################################################################################################
Les commandes suivantes sont utilisées pour afficher le ReplicaSet
kubectl obtenir rs
Quel est le nombre minimum d'adaptateur(s) réseau par machine virtuelle nécessaire pour former un cluster Kubernetes multinoeud ?
2
Quelle sous-commande de gcloud est utilisée pour définir l'ID du projet ?
config
Lequel est l'outil de conteneurisation parmi les suivants ?
Docker
Quel outil n'est pas installé dans le nœud Worker d'un cluster Kubernetes
Quel service de Google Cloud Platform est utilisé pour créer un cluster Kubernetes ?
Moteur Kubernetes
La commande pour démarrer le tableau de bord depuis minikube
le jeu de réplicas garantit : un nombre spécifique de répliques fonctionne à tout moment
Lequel n'est pas un outil de regroupement de conteneurs ?
ansible
Quelle est la version api valide de POD dans le fichier objet yaml ?
v1
Créer une image personnalisée
Le Dockerfile est utilisé.
Chaque POD obtient une adresse IP
Quel est le nombre minimum de VM nécessaires pour configurer un cluster Kubernetes multinoeuds avec kubeadm ?
3
Par quel outil un cluster Kubernetes à nœud unique peut-il être installé
minikube
Pour garantir une haute disponibilité dans un cluster Kubernetes multi-nœuds, combien de nœuds maîtres sont nécessaires au minimum ?
3
Pour voir les paramètres de configuration détaillés d'un POD
La commande kubectl describe <nomdupod> est utilisée
la commande pour démarrer minikube
minikube démarrer
quelle sous-commande de gcloud est utilisée pour créer un cluster Kubernetes ?
conteneur
Quel outil est utilisé dans aws cli pour créer et gérer un cluster kubernetes dans aws ?
Devrions-nous garder le pare-feu désactivé pour interconnecter toutes les VMs dans un cluster Kubernetes multi-nœuds.
oui
Invalid request. Please provide text for translation.
htps://medium.com/@sensri108/exemples-de-pratique-dumps-tps-pour-l-examen-d-administrateur-kubernetes-certifié-cka-ckad-par-cncf-
4826233ccc22
htps://de.slideshare.net/vinodmeltoe/cka-dumps

********************Pods****************************************
kubectl obtenir des pods

kubectl run nginx --image=nginx --generator=run-pod/v1 --> créer un pod avec le nom nginx
kubectl run redis --image=redis123 --generator=run-pod/v1 --> créer pos
kubectl edit pod podname --> pour éditer les pods
kubectl décrire pod podname-id --> pour obtenir des informations détaillées
kubectl obtenir des pods -o large
kubectl supprimer pod webapp --> supprimer pod
Conteneurs en cours d'exécution 1/2 --> Conteneurs en cours d'exécution dans des pods / Total des conteneurs dans des kubepods

Créez un nouveau pod avec le nom 'redis' et avec l'image 'redis123' --> En utilisant le fichier ###### en attente

curl -LO htps://storage.googleapis.com/kubernetes-release/release/`curl -s

htps://storage.googleapis.com/kubernetes-release/release/stable.txt`/bin/linux/amd64/kubectl
chmod +x ./kubectl
mv ./kubectl /usr/local/bin/kubectl
kubectl version --client
*********************************Réplique*****************
kubectl obtenir replicaset
'kubectl get replicaset' -o large
kubectl décrire replicaset
le replicaset garantit que les pods doivent être en état de fonctionnement dans le replicaset

version d'API correcte pour replicaset : apps/v1

kubectl créer -f replicaset-définition-1.yaml --> créer replicaset
kubectl obtenir rs
kubectl supprimer replicaset nomdereplicaset
kubectl modifier replicaset nomduréplicat
si le replicaset est modifié, soit supprimer les pods
ou supprimez le replicaset avant de supprimer ou d'exporter le fichier de définition
kubectl get rs new-replica-set -o yaml > new-replica-set.yaml
kubectl supprimer replicaset nomduréplicat
kubectl create -f new-replicaset.yaml
mettez à l'échelle le replicaset en modifiant soit le fichier yaml soit en exécutant kubectl edit replicaset new-replica-set à 5

kubectl scale rs new-replica-set -r-replicas=5

*********************************Déploiements*****************
kubectl obtenir déploiement
kubectl obtenir déploiement -o large
kubectl create -f définition-de-déploiement.yaml
---versionApi : apps/v1type : Déploiement

htpd-frontend
spec
replicas: 3
selector
matchLabels
htpd-frontend-pods
modèle

labels
htpd-frontend-pods
spec
conteneurs
conteneur-htpd-frontend
htpd:2.4-alpine
commande :
- sh
-c
- echo Bonjour Kubernetes ! && sleep 3600

********************************Espaces de noms*****************
kubectl obtenir des espaces de noms
kubectl get pods --namespace=spacename --> obtenir des pods dans les espaces de noms
kubectl run redis --image=redis --namespace=finance --generator=run-pos/v1 --> créer un pod dans le namespace
kubectl obtenir des pods --tous les espaces de noms

********************************services*****************
kubectl obtenir le service
Le service par défaut de Kubernetes est clusterIP
kubectl décrire service
kubectl créer -f service-definaton.yaml
Fichiers de définition de service

---
versionApi: v1
type: Service

service-webapp
spec
NodePort
ports
- targetPort: 8080
8080
nodePort: 30080
selector
 application-web-simple

*******************************commentaires impératifs*****************
kubectl run nginx-pod --image=nginx:alpine --generator=run-pod/v1 --> créer un pod
kubectl run nginx-pod --image=nginx:alpine --generator=run-pod -lter=db --> création avec étiquette
kubectl expose pod redis --port=6327 --name redis-service --> créer un service pour exposer le port de l'application
kubectl créer un déploiement webapp --image=kodekloud/webapp-color --> créer un déploiement
kubectl scale webapp --replicas=3
kubectl expose deployment webapp --type=NodePort --port=8080 --name=webapp-service --dry-run -o yaml > webapp-service.yaml

*******************************planification et suivi*****************
kubectl obtenir des pods

kubectl top nœud

kubectl haut pod
kubectl logs webapp1

Mise à jour roulante ALM, conteneur de variable d'environnement

kubectl obtenir déploiements
kubectl décrire déploiements frontend
Mise à jour continue
Créer un pod avec les spécifications données :

webapp-vert
Image : kodekloud/webapp-color
Arguments de ligne de commande : --color=vert

apiVersion: v1
Pod

webapp-vert
étiquettes
application-web-verte
spec
conteneurs
application-web-simple
kodekloud/webapp-couleur
command: ["python", "app.py"]
args: ["--color", "pink"]
*****************************Variable d'environnement ****************
ubectl get pod webapp-color -o yaml > webapp-color.yaml
kubectl obtenir des configmaps
kubectl décrire les configmaps db-config
kubectl créer un configmap \
> carte-config-webapp --from-literal=APP_COLOR=bleu-foncé
kubectl obtenir des secrets
kubectl créer un secret générique db-secret --from-literal=DB_HOST=sql01 --from-literal=DB_USER=root --from-
DB_Password=motdepasse123 --< créer un secret
*****************************Pods multiconteneurs**************** le conteneur d'initialisation a besoin de pratiques#######
multcontainer.yaml
versionApi: v1
Pod
métadonnées :
jaune
spec
conteneurs
citron
busybox

or
redismaster

kubectl exec -it app cat/log/app.log --> obtenir le fichier journal

******************************* Maintenance du cluster #########################################
kubectl obtenir des nœuds
kubectl get déploiement pour voir le nombre d'applications hébergées sur le cluster
Nous devons retirer le node01 pour maintenance. Videz le node de toutes les applications et marquez-le comme non planifiable.
kubectl vider node01 --ignorer les ensembles de démons --
kubectlctl uncordon node01 --> planifier le nœud
kubectl décrire nœud maître
kubectl vider node02 --ignorer-daemonsets --forcer
Node03 a nos applications critiques. Nous ne voulons pas programmer d'autres applications sur node03. Marquez node03 comme non planifiable mais ne le faites pas.
supprimer toutes les applications actuellement en cours d'exécution dessus

kubectl cordon node03

*****************Mise à niveau du cluster**************************
kubectl obtenir le cluster --> obtenir la version actuelle du cluster
plan de mise à niveau kubead
kubectl drain master --ignore-daemonsets --> vider le nœud et désinscrire
-- mettre à jour kubeadm
installer mise à jour appliquer

apt installer kubeadm=1.12.0-00

kubeadm mise à niveau v1.12.00
apt install kubelet=1.12.0-00
kubectl uncordon maître --> rendre le nœud maître planificateur
kubectl drain node01 --ignore-daemonsets --déchargez la charge et marquez comme non planifiable
--> mettre à niveau le nœud de travail

apt install kubeadn=1.12.0-00

apt installer kubelet=1.12.0-00
kubeadm mise à jour de la configuration du nœud --version-kublet$(kubelet --version | cut -d ' ' -f 2)
aster $ kubeadm mettre à niveau le nœud config --version-kubelet $(kubelet --version | cut -d ' ' -f 2)
[kubelet] Téléchargement de la configuration pour le kubelet depuis le ConfigMap "kubelet-config-1.12" dans l'espace de noms kube-system
[kubelet] Écriture de la configuration du kubelet dans le fichier "/var/lib/kubelet/config.yaml"
[mise à niveau] Le configurato
n pour ce nœud a été mis à jour avec succès !
[mise à niveau] Maintenant, vous devriez procéder à la mise à niveau du paquet kubelet en utilisant votre gestionnaire de paquets.

apt installer kubelet

*******************Sauvegarde et stockage****************************
vérifier la version d'etcd
kubectl logs etcd-maître -n kube-système
kubectl décrire pod etcd-master -n kube-system -> vérifier pour listen-client
emplacement du certificat serveur
certificat de l'autorité
Prenez une sauvegarde avant de redémarrer le nœud maître

ETCDCTL_API=3 etcdctl --endpoints=htps://[122.0.0.1]:2327 --cacert=/etc/kubernetes/pki/etcd/ca.crt \

--cert=/etc/kubernetes/pki/etcd/server.crt --key=/etc/kubernetes/pki/etcd/server.key \
capture sauvegarder /tmp/snapshot-pre-boot.db

RESTORE le snapshot edcd

ETCDCTL_API=3 etcdctl --endpoints=htps://[122.0.0.1]:2327 --cacert=/etc/kubernetes/pki/etcd/ca.crt \
--nom=maître \
/etc/kubernetes/pki/etcd/server.crt
/var/lib/etcd-from-backup
master=htps://122.0.0.1:2380
etcd-cluster-1
htps://122.0.0.1:2380 \
restauration de l'instantané /tmp/snapshot-pre-boot.db
*********************************Certificat********************************

Fichier de certificat du serveur Kube-api :

cat /etc/kubernetes/manifests/kube-apiserver.yaml
/etc/kubernetes/pki/apiserver-etcd-client.crt

openssl x507 -in /etc/kubernetes/pki/apiserver.crt -text

certificat du serveur API kube
openssl x507 -in /etc/kubernetes/pki/apiserver.crt -text --> serveur API
openssl x507 -in /etc/kubernetes/pki/etcd/server.crt -text --> configuration du serveur etcd
serveur api
openssl x507 -in /etc/kubernetes/pki/ca.crt -text --> CA Racine

openssl x507 -req -in /etc/kubernetes/pki/apiserver-etcd-client.csr -CA /etc/kubernetes/pki/etcd/ca.crt -CAkey

/etc/kubernetes/pki/etcd/ca.key -CAcreateserial -out /etc/kubernetes/pki/apiserver-etcd-client.crtmaster --> Générer le nouveau certificat
export dr='--dry-run=client -o yaml'
export now='--grace-period=0 --force'

k run pod --image=nginx -- dormir 1j

k supprimer pod pod $now --> Supprimé de force

#################################################################################################################
Q1 :
Réponse :
k config obtenir-contexte -o nom
k config obtenir-contexte -o nom > /opt/cours/1/contextes
chat /opt/course/1/contexts

Avec Kubectl
kubectl config current-context # Afficher les contextes actuels
echo "kubectl config current-context" > /opt/course/1/context_default_kubectl.sh
cat /opt/course/1/context_default_kubectl.sh
sh /opt/course/1/context_default_kubectl.sh

Sans Kubectl
vous obtiendrez tout le contexte dans le texte .kube/config
chat /.kube/config | grep -i contexte-actuel
cat /.kube/config | grep -i contexte-actuel | sed 's/contexte-actuel: //'
sh /opt/course/1/context_default_no_kubectl.sh
#################################################################################################################
Q2 :
kubectl config utiliser-contexte k8s-c1-Hello
k run -n default pod1 --image=htpd:2.4.41-alpine --dry-run=client -o yaml
k run -n default pod1 --image=htpd:2.4.41-alpine --dry-run=client -o yaml > 2.yaml
éditez le fichier 2.yaml et mettez à jour le nom du conteneur : pod1-container
programme pod : sous spécification obtenir kubectl obtenir les nœuds en tant que nom de maître

spec
cluster1-maître

k créer -f 2.yaml
versionAPI: v1
Pod

creatonTimestamp: null
labels
exécuter : pod1

pod1
spéc
conteneurs
htpd:2.4.41-alpine
pod1-conteneur changement
resources: {}
ClusterFirst
Toujours
tolérances # ajouter
Pas de programme # ajouter
node-role.kubernetes.io/control-plane # ajouter
# ajouter
cluster1-controlplane1
status: {}

k obtenir des pods -n par défaut pod1

k obtenir des pods -n par défaut pod1 -o large # vérifier si le nœud s'exécute sur le nœud maître ou non
k décrire pod pod1 -n par défaut
#################################################################################################################

Q3
kubectl config utiliser-contexte k8s-c1-H # définir ce contexte
k obtenir tout -n projet-c13 # pour vérifier les pods
k obtenir des pods -n projet-c13 # pour vérifier les pods
k échelle étatfulset -n projet-c13 o3db --réplicas=1 # Réduire à 1 réplique
k obtenir des pods -n projet-c13 # pour vérifier les pods maintenant un pod devrait fonctionner
k obtenir tout -n projet-c13 # pour vérifier les pods maintenant un pod devrait s'exécuter

#################################################################################################################
Q4
kubectl config utiliser-contexte k8s-c1-H
k run -n default ready-if-service-ready --image=nginx:1.16.1-alpine --dry-run=client -o yaml > 4.yaml
modifier le fichier 4.yaml

configure livenessprobe et readinessprobe, consultez le document et mettez sous la section espace

livenessProbe
exécuter :
commande :
vrai
readinessProbe
exec:
commande :
- 'sh'
'c'
- 'wget -T2 -0- htp://service-am-i-ready:80'

enregistrez le fichier et créez le pod

k obtenir des pods -n défaut # vérifier si les pods avec le même nom sont trouvés ou non
k créer -f 4.yaml
vérifiez l'état des pods et décrivez le service et cela devrait échouer avec l'alerte de disponibilité

k run suis-je-prêt -n défaut --image=nginx:1.16.1-alipne --labels="id=cross-servicer-prêt" --dry-run=client -o yaml

k get svc -n default servcie-am-i-ready
k obtenir ép -n par défaut
k run suis-je-prêt -n par défaut --image=nginx:1.16.1-alipne --labels="id=service-croisé-prêt"
k obtenir des pods -n par défaut am-je-prêt
k obtenir svc -n défaut service-am-i-ready
k obtenir ep -n par défaut
k obtenir des pods -n par défaut am-i-ready -o large

Maintenant, le premier pod doit être en statut prêt :

k obtenir des pods -n par défaut prêt-si-service-prêt
k décrire pod -n défaut prêt-si-service-prêt # vérifier l'état d'exécution du pod

# 4_pod1.yaml
versionApi: v1
Pod
metadata:
creatonTimestamp: null
labels
exécuter : prêt-si-service-prêt
prêt-si-service-prêt
spéc
conteneurs
nginx:1.16.1-alpine
prêt-si-service-prêt
resources: {}
livenessProbe # ajouter à partir d'ici

exécuter :
commande
vrai
readinessProbe
exécuter:
commande :
sh
- -c
- 'wget -T2 -O- htp://service-am-i-ready:80' # jusqu'ici
ClusterFirst
Toujours
status: {}

#################################################################################################################
Q5
kubectl config utiliser-contexte k8s-c1-H
k obtenir des pods --tous-noms ou k obtenir des pods -A
k get pods -A --sort-by=metadata.creatonTimestamp
echo "k get pods -A --sort-by=metadata.creatonTimestamp" > /opt/course/5/find_pods.sh
cat /opt/course/5/trouver_des_pods.sh
sh /opt/course/5/find_pods.sh

k obtenir des pods -A --trier_par=metadata.uid

echo "kubectl get pods -A --sort-by=metadata.uid" > /opt/course/5/find_pods_uid.sh
sh /opt/course/5/find_pods_uid.sh
#################################################################################################################
Q6
kubectl configurer le contexte k8s-c1-H
copiez le yaml du document k8s avec 6.yaml
modifier le nom du volume persistant : safari-pv

VolumePersistant
versionApi: v1

safari-pv
spec
capacité
2Gi
accessModes
LireÉcrireUneFois
hostPath
/Volumes/Donnees
k obtenir pv
k create -f 6.yaml
k obtenir pv
**************************************
nom de la réclamation de volume persistant : persistentvolume claim

mise à jour : nom safari-pvc

espace de noms : projet-tger
2Gi
mode d'accès : lecture-écriture
ne pas définir le nom de la classe de stockage

k obtenir pvc
k créer -f 6-pvc.yaml

PersistentVolumeClaim
v1

safari-pvc
namespace: projet-tger
spec
accessModes
LectureEcritureUneFois
resources
requests
2Gi

k obtenir pvc -n projet-tger

****************************************
k créer le déploiement safari -n project-tger --image=hhpd:2.4.41-alpine --dry-run=client -o yaml > 6-dep.yaml
mettez à jour le fichier yaml avec le nom de volume de montage selon la question

spéc
volumes
vol
hostpath
/tmp/données-safari
volumeMounts
vol
/tmp/données-safari
k obtenir déploiements -A

apiVersion: apps/v1
Déploiement

creatonTimestamp: null
étiquettes
safari
safari
projet-tger
spécifications
replicas: 1
selector
matchLabels
safari
strategy: {}
modèle

creatonTimestamp: null
labels
safari
spec
volumes # ajouter
données # ajouter
persistentVolumeClaim # ajouter
safari-pvc # ajouter
conteneurs
hhpd:2.4.41-alpine
conteneur
volumeMounts # ajouter
données ajouter
/tmp/données-safari ajouter

k créer -f 6-dep.yaml
vérifiez les déploiements et décrivez le déploiement
#################################################################################################################
Q2 :
kubectl config utiliser-contexte k8s-c1-H

Afficher l'utilisation de la résurgence de nœud

k sommet nœud # utilisation des ressources
echo "kubectl top node" > /opt/course/2/node.sh
cat /opt/cours/2/node.sh
sh /opt/course/2/node.sh

Afficher les pods et leur utilisation des ressources de conteneur

kubectl top pods --containers

echo "kubectl top pods --container" > /opt/course/2/pod.sh
cat /opt/course/2/pod.sh
sh /opt/course/2/pod.sh
vérifiez les deux fichiers en utilisant ls -lrt
#################################################################################################################
Q8
kubectl config utiliser-contexte k8s-c1-H
Noeud de marché SSh, découvrez l'application DNS
toucher /opt/course/8/composants-maaster.txt
Copiez le contexte de la question
faire ssh cluster1-master1
k obtenir tout -n kube-system | grep -i dns
k obtenir tout -n kube-system | grep -i etcd
ls /etc/kube*/manifests | grep etcd
k obtenir tous -n kube-system | grep -i kube-controller-manager
k obtenir tout -n kube-system | grep -i kube-scheduler
k obtenir tout -n kube-system | grep -i kube-apiserver
k get all -n kube-system | grep -i kubelet # le kubelet n'est pas un service, c'est un processus

type de dns
etcd : pod statique
kube-controller-manager Type : pod statique
kube-scheduler Type : pod statique
pod statique
processus
#################################################################################################################
Q7
kubectl config utiliser-contexte k8s-c2-AC
arrêter le planificateur kube :

ssh cluster2-maître1
k obtenir des pods -n kube-system | grep -i kube-scheduler
cd /etc/kub*/manifests
mv kube-scheduler.yaml kube-scheduler_org.yaml
k get pods -n kube-system | grep -i kube-scheduler # le pod doit être terminé

créer un pod en mode non planifié

k exécuter pod manuel-schedule --image=hhpd:2.4-alpine
k obtenir pod manuel-programmation

planifier manuellement le pod

restaurer le fichier mv kube-scheduler_org.yaml kube-scheduler.yaml
vérifier le pod de planificateur
k get pods -n kube-system | grep -i kube-scheduler
k obtenir pod manuel-programmé
k exécuter programme-manuel --image=hhpd:2.4-alpine

démarrer le planificateur et exécuter le 2ème pod

k obtenir pod manual-schedule -o yaml > 7.yaml

fichier vi 7.yaml
mettre à jour le nom du nœud : cluster2-controlplane1 ajoutez le nom du nœud controlplane
ajouter dans la section spécifications

travailleur-cluster1
k -f 7.yaml remplacer --force
k obtenir des pods manual-schedule1 -o large
k créer -f 7.yaml

#################################################################################################################
Q10

Un ClusterRole|Rôle définit un ensemble de permissions et où il est disponible, dans l'ensemble du cluster ou juste dans un seul Namespace.
Un ClusterRoleBinding|RoleBinding connecte un ensemble de permissions avec un compte et définit où il est appliqué, dans tout le cluster ou juste
un seul espace de noms.
À cause de cela, il y a 4 combinaisons RBAC différentes et 3 valides :

Rôle + Liaison de rôle (disponible dans un seul espace de nom, appliqué dans un seul espace de nom)
ClusterRole + ClusterRoleBinding (disponible à l'échelle du cluster, appliqué à l'échelle du cluster)
ClusterRole + RoleBinding (disponible à l'échelle du cluster, appliqué dans un seul Namespace)
Rôle + ClusterRoleBinding (NON POSSIBLE : disponible dans un seul Namespace, appliqué à l'échelle du cluster)

kubectl config utiliser-contexte k8s-c1-H

Créer un compte de service
k créer un processeur --namespace project-hamster
k obtenir sa -A

créer un rôle permettant à SA de créer des secrets et des configmaps dans NS

kubectl api-resources # vérifier le nom de la ressource dans la première colonne
k créer un rôle processeur -n projet-hamster --verbe=créer --ressource=secrets,configmaps
k créer le rôle processeur -n projet-hamster --verb=create --resource=configmaps
k obtenir rôle -n projet-hamster
k décrire le rôle -n projet-hamster
k obtenir la configmap -n projet-hamster

Créer un lien de rôle

k créer un rolebinding -n projet-hamster processeur --serviceaccount=projet-hamster:processeur --role=processeur --dry-run=client -o yaml
k créer un rolebinding -n projet-hamster processeur --serviceaccount=projet-hamster:processeur --role=processeur

k obtenir des liaisons de rôle -n projet-hamster # vérifier la même chose

k décrire les liaisons de rôle -n projet-hamster # décrire le même
vérifier si vous pouvez créer un compte de service ou non
k auth peux-je créer un secret --namespace projet-hamster --liste --en-tant-que=system:serviceaccount:project-hamster:processor # oui
k auth peut-je créer des configmaps --namespace project-hamster --list --as=system:serviceaccount:project-hamster:processor # oui
k auth puis-je créer des pods --namespace projet-hamster --list --as=system:serviceaccount:project-hamster:processor # non

➜ k -n project-hamster auth puis-je créer un secret \

--en système:serviceaccount:project-hamster:processeur
oui

➜ k -n projet-hamster auth puis-je créer un configmap \

--en tant que compte de service :serviceaccount:project-hamster:processor

oui

➜ k -n projet-hamster auth puis-je créer un pod \

--en tant que compte de service :serviceaccount:project-hamster:processor

non

➜ k -n projet-hamster auth puis-je supprimer le secret \

--en tant que compte de service :serviceaccount:project-hamster:processor

non

➜ k -n projet-hamster auth puis-je obtenir le configmap

--en tant que compte de service:project-hamster:processor
non

#################################################################################################################
Q11 :
kubectl config utiliser-contexte k8s-c1-H

Créer un daemonset : utiliser des documents et utiliser des manifests

définir le processeur et la mémoire

pod daemonset tous les nœuds master, travailleurs

# 11.yaml
apiVersion: applications/v1
DémonSets passer de Deployment à Daemonset

creatonTimestamp: null
labels # ajouter
ds-important # ajouter
18426a0b-5f57-4e10-723f-c0e028e82462
ds-important
espace de noms : projet-tger # important
spéc
#replicas: 1 # retirer
sélecteur
matchLabels
ds-important ajouter
18426a0b-5f57-4e10-723f-c0e028e82462
#strategy: {} # enlever
modèle

creatonTimestamp: null
labels
ds-important # ajouter
18426a0b-5f57-4e10-723f-c0e028e82462 # ajouter
spéc
conteneurs
hhpd:2.4-alpine
ds-important
ressources
demandes ajouter
10m # ajouter
10Mi ajouter
tolérances ajouter
Pas de planification ajouter
 nœud-rôle.kubernetes.io/plan-de-controle # ajouter
#status: {} # supprimer

k créer -f 11.yaml
vérifiez si toutes les ressources ont été créées ou non
#################################################################################################################
Q12
kubectl config utiliser-contexte k8s-c1-H

k créer un déploiement --namespace projet-tger deploy-important --image=nginx:1.12.6-alpine --réplicas=3 --dry-client=client -o yaml >
Le texte à traduire est manquant.
vi 12.yaml

# 12.yaml
apiVersion : apps/v1
Déploiement

creatonTimestamp: null
étiquettes
très-important # changement
déployer-important
espace de noms : projet-tger # important
spec
replicas: 3 changement
selector
matchLabels
très-important # changement
strategy: {}
modèle

creatonTimestamp: null
étiquettes
très-important changement
spécification
conteneurs
nginx:1.12.6-alpine
conteneur1 # changement
resources: {}
kubernetes/pause # ajouter
container2 ajouter
affinité # ajouter
podAntAffinité # ajouter
# ajouter
labelSelector # ajouter
matchExpressions ajouter
id # ajouter
opérateur : Dans # ajouter
valeurs ajouter
très-important # ajouter
kubernetes.io/nom_d_hôte # ajouter
status: {}

enregistrer le fichier et exécuter le fichier

k créer -f 12.yaml
k obtenir le déploiement -n projet-tger # 3 répliques et 2 prêtes et disponibles aussi 2
k obtenir les pods -n projet-tger -o large # 3 pods dont 2 en cours d'exécution et 1 en attente

solution valable
k décrire le déploiement -n projet-tger
--> vérifier le nom
id

#################################################################################################################
Q13
kubectl config utiliser-contexte k8s-c1-H

Créer un pod avec 3 conteneurs + montage de volume par pod + non partagé ou persistant avec un autre pod
aire de jeu à conteneurs multiples
nginx:1.12.6-alpine
VAR_ENV : MON_NOM_DE_NOBE
c2 : busybox:1.31-1
écrire la commande de date de sortie chaque seconde avec le fichier de volume partagé date.log utilisez while true:
c3 : busybox:1.31.1 et envoyer le contenu du fichier date.log depuis le volume partagé vers stdout et utiliser tril-f
vérifiez le journal de c2 pour confirmer la configuration

k run mult-container-playground -n défaut --image=nginx:1.12.6-alpine --dry-run=client -o yaml

ouvrez le fichier 13.yaml avec vi

13.yaml
v1
Pod

creatonTimestamp: null
labels
exécuter : mult-container-playground
terrain de jeu mult-container
spec
conteneurs
nginx:1.12.6-alpine
c1 changement
resources: {}
env : # ajouter
MON_NOM_DE_NŒUD # ajouter
valueFrom # ajouter
fieldRef # ajouter
spec.nodeName ajouter
montagesDeVolume ajouter
vol ajouter
/vol # ajouter
busybox:1.31.1 # ajouter
c2 ajouter
command: ["sh", "-c", "while true; do date >> /vol/date.log; sleep 1; done"] # add
montages de volume ajouter
vol # ajouter
/vol # ajouter
busybox:1.31.1 # ajouter
c3 ajouter
command: ["sh", "-c", "tail -f /vol/date.log"] # ajouter
montagesDeVolume # ajouter
vol # ajouter
/vol # ajouter
ClusterFirst
Toujours
volumes ajouter
vol # ajouter
emptyDir: {} ajouter
status: {}

vérification
k créer -f 13.yaml
k obtenir des pods -n par défaut

k décrire pod podname -n par défaut

k exec -it mult-container-playground -c c1 -- printenv # imprimer la variable d'environnement
k exec -it mult-container-playground -c c1 -- printenv | grep -i MY_NODE_NAME # imprimer la variable d'environnement

k exec -it mult-container-playground -c c1 -- cat /votre/vol/path/date.log # écrit le journal chaque seconde

k exec -it mult-container-playground -c c3
#################################################################################################################
Q14
kubectl config utiliser-contexte k8s-c1-H

Combien de nœuds principaux :

k obtenir les nœuds

Combien de nœuds de travail :

k obtenir les nœuds

Qu'est-ce que le CIDR de service :

ssh cluster1-maître1
k get pods -n kube-system | grep -i kube-api # cela montre le pod statique
cd /etc/kub*/mani/kube-apiserver.yaml
cat /etc/kub*/mani/kube-apiserver.yaml | grep -i plage

Quel CNI de mise en réseau et localisation :

cd /etc/cni/net.d
ls -lrt
chat 10.onde.congflist

Suffixe du pod statc pour exécuter cluster1-worker1

statc pod est le nom du nœud

touche /opt/course/14/cluster-info
1:1
2:2
3 : 10.76.0.0/12
4 : tisser, /etc/cni/net.d/10-weave-conflist
5 : -cluster1-workeur1

cat /opt/course/14/cluster-info
#################################################################################################################
Q15
kubectl config utiliser-contexte k8s-c2-AC

touch /opt/course/15/cluster_events.sh
echo 'kubectl get events -A sort-by="metadata.creatonTiestamp"' > /opt/course/15/cluster_events.sh
sh /opt/course/15/cluster_events.sh

kubectl get pods -A -o wide | grep kube-proxy

kubectl delete pod podname -n kube-system
kubectl get pods -A -o large | grep kube-proxy
kubectl get events -n kube-system --sort-by="metadata.creationTimestamp" --> copier les événements dans /opt/course/15/pod_kill.log

kubectl get pods -A -o wide | grep kube-proxy --> obtenir le nom du pod
ssh cluster2-travailleur1
crictl ps
copiez le numéro du conteneur ou le nom par rapport au nom du pod
la tâche est de tuer le conteneur
crictl arrêter 653345545(id de conteneur)
crictl rm 653345545(ID_de_conteneur)
crictl ps

kubectl get events -n kube-system --sort-by="metadata.creationTimestamp" --> copier les événements vers /opt/course/15/container_kill.log
#################################################################################################################
Q16
kubectl config utiliser le contexte k8s-c1-H

Créer un espace de noms

kubectl créer ns cks-master

Écrivez tous les ns des ressources k8s

echo "kubectl api-resources --namespaced -o name" > /opt/course/16/resources.txt
cat /opt/course/16/resources.txt # vérifier la sortie

trouver des projets* avec les plus hauts rôles NS

kubectl obtenir des rôles -A | grep -i projet-c14 --no-entêtes | wc-1

environ 300

k obtenir ns
vérifiez avec d'autres ns également juste pour confirmation.
kubectl get roles -A | grep -i project-c14 --no-headers| wc-1

vi /opt/cours/16/espace-namespace-bondé.txt
ajouter
projet-c14 300
enregistrer le fichier et afficher le fichier /opt/course/16/crowded-namespace.txt

#################################################################################################################
Q12
kubectl config utilisateur-contexte k8s-c1-H

kubectl run -n project-tgertgers-reunite --image=hhrpd:2.4.41-alpine --labels="pods=container,container=pod" --dry-run=client -0 yaml

kubectl run -n project-tgertgers-reunite --image=hhrpd:2.4.41-alpine --labels="pods=container,container=pod"

k obtenir des pods -n projet-tger -0 large # obtiendra le nom du nœud sur lequel le pod est en cours d'exécution

cluster1-travailleur2

ssh cluster1-worker2
crictl ps | grep -itger-reunite
copier l'identifiant de contenu et écrire dans un fichier txt

crictl inspect 5656645656565(containerID) | grep info.runtmeType

vérifiez les détails

vi /opt/course/12/pod-container.txt
5656645656565 io.containerd.runc.v2

écrire des journaux dans /opt/course/12/pod-container.log

crictl logs 5656645656565
crictl logs 5656645656565 # copiez les journaux et ajoutez-les dans un fichier txt
#################################################################################################################
Q18
kubectl config utiliser le contexte k8s-c2-CCC

kubelet ne fonctionne pas sur le worker, réparez-le,

k obtenir des nœuds # 2 nœuds, l'un ne sera pas prêt

ssh cluster3-travailleur1
ps aux | grep -i kublet # vérifier s'il est en cours d'exécution ou non

statut du service kubelet

service kubelet démarrer et vérifier s'il démarre ou non
--> vérifier l'emplacement de kubelet : /usr/bin/kubelet et dans le fichier de configuration, il est configuré comme /usr/local/bin/kubelet
Corrigez le fichier et enregistrez-le
--> redémarrer le service systemctl daemon-reload && systemctl restart kubelet
--> service kubelet statut
--> k obtenir les nœuds # il devrait être dans l'état prêt

écrire la raison du problème dans /opt/course/18/reason.txt

Chemin incorrect défini pour kubelet /usr/local/bin/kubelete
chemin corrigé pour kubelet en tant que /usr/bin/kubelet
fichier info /etc/systemd/system/kubelet.service.d/10-kube.conf
#################################################################################################################
Q17
Test secret
kubectl config utiliser-contexte k8s-c2-CCC

k créer ns secret # créer un secret

17_secret1.yaml
versionApi: v1
data
halt: IyEgL2Jpbi7zaAo...
Secret

creatonTimestamp: null
secret1
espace de noms : secret changement

k run -n secret secret-pod --image=busybox:1.31.1 --dry-run=client -o yaml -- sh -C sleep 1d > 17.yaml

vi 17.yaml
# 17.yaml
apiVersion: v1
Pod
translatedText
 creatonTimestamp: null
labels
exécuter : pod-secret
pod-secret
secret # ajouter
spécifications
conteneurs
args
- sh
- -c
- dormir 1j
busybox:1.31.1
pod-secret
resources: {}
env : # ajouter
UTILISATEUR_APP ajouter
valueFrom ajouter
secretKeyRef # ajouter
secret2 # ajouter
utilisateur # ajouter
APP_PASS # ajouter
valueFrom # ajouter
secretKeyRef : # ajouter
secret2 ajouter
passer Ajouter
volumeMounts # ajouter
secret1 # ajouter
/tmp/secret1 # ajouter
lecture seule # ajouter
ClusterFirst
Toujours
volumes # ajouter
secret1 # ajouter
secret # ajouter
secret1 # ajouter
status: {}

mettre à jour l'emplacement du fichier yaml secret dans le fichier yaml pour cela vérifier secret1.yaml et mettre à jour namespace = secret
k obtenir des secrets -n secrets
k create -f secret1.yaml # qui est spécifié dans la question

k create secret generic secret2 -n secret --from-literal="user=user1" --from-literal="pass=1234"

k décrire secret secret2
copiez le nom d'utilisateur et le mot de passe et vérifiez echo adbcc | base64 --décoder

#################################################################################################################
Q20
kubectl config utiliser le contexte k8s-c2-CCC

Mise à niveau de la version de Node d'ancienne à nouvelle

kubectl get nodes -0 large

Cluster3-maître1 v 1.25.1

ssh cluster3-travailleur2
version kubeadmin
1.25.2
kubelet --version
v.1.24.6

mettre à niveau kubelet

mise à niveau de kubelet et kubectl
apt-mark kubelet kubectl && \
apt-get mettre à jour && apt-get installer -y kubelet=1.25.2-00 kubectl=1.25.2
apt-mark tenir kubelet kubectl
sudo systemctl daemon-reload
sudo systemctl redémarrer kubelet
kubeadmin rejoindre # rejoindre le travailleur au cluster

********************************************************
ssh Cluster3-master1
kubeadm token créer --imprimer-commande-joindre
copier la sortie et la coller dans le nœud de travail
********************************************************
kubectl obtenir des nœuds
#################################################################################################################
Q21
kubectl config utiliser-contexte k8s-c2-CCC

Créer un pod statique + mémoire + service

ssh cluster3-maître1
cd /etc/kub*/mani*
ls -rlt
Allez dans un autre terminal où le contexte est défini
k exécuter mon-pod-statc -n par défaut --image=nginx:1.16-alpine --dry-run=client -o yaml > 21.yaml
vi 21.yaml
/etc/kubernetes/manifests/mon-pod-statique.yaml
versionApi: v1
Pod

creatonTimestamp: null
étiquettes
exécuter : mon-pod-statc
mon-pod-statique
spécification
conteneurs
nginx:1.16-alpine
mon-pod-statique
ressources
requests
10m
20Mi
PremierCluster
Toujours
status: {}

ajoutez uniquement les informations sur les ressources mémoire et CPU

enregistrer le fichier dans le répertoire manifeste
k obtenir des pods

k décrire les pods

**************************************************************************
créer un service NodePort
k expose pod my-statc-pod-cluster3-master1 -n par défaut --name=statc-pod-service -port=80 --type=nodePort --dry-run=client -o yaml
k obtenir svc -A
vérifiez l'IP et le port en utilisant le terminal
k -n défaut exec -it -- ping 10.32.0.4
#################################################################################################################
Q22
kubectl config utiliser-contexte k8s-c2-AC
vérifier la validation du certificat du serveur kubeapi
utilisez openssl ou cfssl
ssh cluster2-maître1

k obtenir po -n kube-système | grep -i kube-api

cd /etc/kub*/mani*
chat kube-apiserver.yaml | grep -i tls-cert
chat /etc/kub*/pki/apiserver.crt
openssl -x507 --noout --text -in /etc/kub*/pki/apiserver.crt | grep -i valide -A 2
copier le certificat de validité dans vi /opt/course/22/expiration

kubeadm certs check-expiration | grep -i apiserver # obtenir la date du certificat en utilisant kubeadm

commande de renouvellement de certificat utilisant kubeadm

touch /opt/course/22/kubeadm-renew-certs.sh
kubeadm certs renouveler apiserver # copiez cette commande et ajoutez-la dans le fichier menton
#################################################################################################################
Q23
kubectl config utiliser le contexte k8s-c2-AC

trouver le problème et les utilisateurs clés de cluster2-worker1

client kubelet
2. serveur kubelet

ssh cluster2-worker1
service kubelet status # vérifier si le service est en cours d'exécution ou non

cd /etc/systemd/system/kubelet.service
chat 10-kubeadm.conf
cat /etc/kub*/kublet.conf | grep -i cert
vous obtiendrez l'emplacement du certificat client qui est un fichier pem

openssl x507 -noout --text dans /var/lib/kubelet/pki/kubelet-client-current.pem | grep -i émetteur

copier l'émetteur dans le fichier d'informations du certificat

openssl x509 -noout --text dans /var/lib/kubelet/pki/kubelet-client-current.pem | grep -i usage -A 10

copier l'utilisation dans le fichier certficate-info

openssl x507 -noout --text dans /var/lib/kubelet/pki/kubelet.crt | grep -i émetteur -A 10

copier l'utilisation dans le fichier info-certificat

openssl x507 -noout --text dans /var/lib/kubelet/pki/kubelet.crt | grep -i usage -A 10

copier l'utilisation dans le fichier certficate-info

écrire des informations dans le fichier et comparer les deux champs

Problèmes : CN : Kubernets
Utilisation étendue des clés : Authentification de client Web TLS

Émetteur : CN = cluster2-worker-ca@16662622
Utilisation étendue de la clé : Authentification de client Web TLS
#################################################################################################################
Q24
kubectl config utiliser-contexte k8s-c1-H
Créer une politique réseau

définir le contexte :

k obtenir tous -o large -n projet-serpent

k get exec -it -n project-snake backend-0 --curl 10.42.0.11:1111

base de données un
k obtenir -it -n projet-serpent backend-0 --ping 10.42.0.11

k get exec -it -n project-snake backend-0 --curl 10.42.0.12:2222

base de données deux
k obtenir -it -n projet-snake backend-0 --ping 10.42.0.12

k get exec -it -n projet-serpent backend-0 --curl 10.42.0.13:3333

stockage de secrets de coffre
k obtenir -it -n projet-serpent backend-0 --ping 10.42.0.13

k get -n projet-tger pods --show-labels

# 24_np.yaml
apiVersion: networking.k8s.io/v1
NetworkPolicy

np-backend
projet-serpent
spécification
sélécteurDePod
matchLabels
serveur
policyTypes
Sortie # la politique concerne uniquement l'Egress

sortie
- # première règle
à: # première condition "à"
podSelector
matchLabels
 db1
ports deuxième condition "port"
TCP
1111
- # deuxième règle
à: première condition "à"
podSelector
matchLabels
db2
ports port
TCP
2222

k obtenir des politiques de réseau -n projet-serpent

k créer -f 24.yaml
effectuer la validation une fois la politique mise en œuvre.

k obtenir des pods -n projet-serpent -o large

pour le port 1111 et 2222, la réponse doit être reçue

k get exec -it -n project-snake backend-0 --curl 10.42.0.13:3333
aucun accès ne devrait l'obtenir
k obtenir exec -it -n projet-snake backend-0 --ping 10.42.0.13

#################################################################################################################
##########
Q25
Sauvegarde Etcd
kubectl config user-context k8s-c3-CCC

créer une sauvegarde et l'enregistrer /tmp/etcd-backup.db

touche 25.yaml
copier la commande de la documentation dans le fichier yaml

ETCDCTL_API=3 etcdctl --endpoints=hhps://[122.0.0.1]:2327 --cacert=/etc/kubernetes/pki/etcd/ca.crt \

/etc/kubernetes/pki/etcd/server.crt
instantané enregistré /tmp/etcd-backup.db

k obtenir des pods -n kube-system

ssh cluster3-maître1
cat /etc/kuber*/manifest*/etcd.yaml | grep -i fichier # vérifier l'emplacement du serveur et du fichier cert, fichier ca, fichier clé

Exécutez la commande : dans le cluster et assurez-vous que vous êtes en ssh

ETCDCTL_API=3 etcdctl --endpoints=hhps://[122.0.0.1]:2327 --cacert=/etc/kubernetes/pki/etcd/ca.crt \
--cert=/etc/kubernetes/pki/etcd/server.crt --key=/etc/kubernetes/pki/etcd/server.key \
instantané sauvegarder /tmp/etcd-backup.db

vérifiez l'emplacement du fichier et le fichier de base de données en tant que sauvegarde effectuée

créer un pod dans le cluster : pour tester la sauvegarde

k exécuter le test --image=nginx --commande dormir 1j
k obtenir des pods

k obtenir des pods -n kube-system | grep wc -l

Restaurer la sauvegarde et s'assurer que le cluster fonctionne toujours.

ETCDCTL_API=3 etcdctl --endpoints=hhps://[122.0.0.1]:2327 --cacert=/etc/kubernetes/pki/etcd/ca.crt \
--cert=/etc/kubernetes/pki/etcd/server.crt --key=/etc/kubernetes/pki/etcd/server.key \
restaurer l'instantané /tmp/etcd-backup.db --dossier-données=/var/lib/etcd-backup-1

cd /var/lib/etcd
ls -lrt

mettez à jour le fichier vi /etc/kub*/mani*/etcd.yaml

mettre à jour le paramètre volumes --> chemin hôte : Chemin : /var/lib/etcd-backup-1
k obtenir des pods -A
k obtenir tout -AC
Cela va arrêter ou suspendre le système pour effectuer une sauvegarde de la base de données et recréer le cluster
k obtenir des pods -A
k obtenir des pods -n kube-system --pas d'en-têtes | wc -l

#################################################################################################################