kubernetes
/
website
mirror of https://github.com/kubernetes/website.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #21106 from feloy/feloy-v1-19 

Update kubectl translation for v1.19
pull/21177/head
Kubernetes Prow Robot 2020-05-25 00:45:11 -07:00 committed by GitHub
parent 558ed98c4e 588bfba93d
commit 04476c833d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 112 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
content/fr/docs/reference/kubectl/cheatsheet.md
View File

@ -43,7 +43,7 @@ complete -F __start_kubectl k
```bash
source <(kubectl completion zsh) # active l'auto-complétion pour zsh dans le shell courant
echo "if [ $commands[kubectl] ]; then source <(kubectl completion zsh); fi" >> ~/.zshrc # ajoute l'auto-complétion de manière permanente à votre shell zsh
echo "[[ $commands[kubectl] ]] && source <(kubectl completion zsh)" >> ~/.zshrc # ajoute l'auto-complétion de manière permanente à votre shell zsh
```
## Contexte et configuration de Kubectl
@ -87,7 +87,7 @@ kubectl config unset users.foo # Supprime l'utilisateur fo
## Création d'objets
Les manifests Kubernetes peuvent être définis en json ou yaml. Les extensions de fichier `.yaml`,
Les manifests Kubernetes peuvent être définis en YAML ou JSON. Les extensions de fichier `.yaml`,
`.yml`, et `.json` peuvent être utilisés.
```bash
@ -145,7 +145,7 @@ EOF
# Commandes Get avec un affichage basique
kubectl get services # Liste tous les services d'un namespace
kubectl get pods --all-namespaces # Liste tous les Pods de tous les namespaces
kubectl get pods -o wide # Liste tous les Pods du namespace, avec plus de détails
kubectl get pods -o wide # Liste tous les Pods du namespace courant, avec plus de détails
kubectl get deployment my-dep # Liste un déploiement particulier
kubectl get pods # Liste tous les Pods dans un namespace
kubectl get pod my-pod -o yaml # Affiche le YAML du Pod
@ -154,20 +154,20 @@ kubectl get pod my-pod -o yaml # Affiche le YAML du Pod
kubectl describe nodes my-node
kubectl describe pods my-pod
# Liste des services triés par nom
kubectl get services --sort-by=.metadata.name # Liste les services classés par nom
# Liste les services triés par nom
kubectl get services --sort-by=.metadata.name
# Liste les pods classés par nombre de redémarrages
kubectl get pods --sort-by='.status.containerStatuses[0].restartCount'
# Affiche les pods du namespace test classés par capacité de stockage
kubectl get pods -n test --sort-by=.spec.capacity.storage
# Affiche les volumes persistants classés par capacité de stockage
kubectl get pv --sort-by=.spec.capacity.storage
# Affiche la version des labels de tous les pods ayant un label app=cassandra
kubectl get pods --selector=app=cassandra -o \
jsonpath='{.items[*].metadata.labels.version}'
# Affiche tous les noeuds (en utilisant un sélecteur pour exclure ceux ayant un label
# Affiche tous les noeuds (en utilisant un sélecteur pour exclure ceux ayant un label
# nommé 'node-role.kubernetes.io/master')
kubectl get node --selector='!node-role.kubernetes.io/master'
@ -252,7 +252,7 @@ kubectl patch sa default --type='json' -p='[{"op": "add", "path": "/secrets/1",
```
## Édition de ressources
Ceci édite n'importe quelle ressource de l'API dans un éditeur.
Édite n'importe quelle ressource de l'API dans un éditeur.
```bash
kubectl edit svc/docker-registry # Édite le service nommé docker-registry
@ -274,7 +274,7 @@ kubectl scale --replicas=5 rc/foo rc/bar rc/baz # Scale plusie
kubectl delete -f ./pod.json # Supprime un pod en utilisant le type et le nom spécifiés dans pod.json
kubectl delete pod,service baz foo # Supprime les pods et services ayant les mêmes noms "baz" et "foo"
kubectl delete pods,services -l name=myLabel # Supprime les pods et services ayant le label name=myLabel
kubectl -n my-ns delete po,svc --all # Supprime tous les pods et services dans le namespace my-ns
kubectl -n my-ns delete pod,svc --all # Supprime tous les pods et services dans le namespace my-ns
# Supprime tous les pods correspondants à pattern1 ou pattern2 avec awk
kubectl get pods -n mynamespace --no-headers=true | awk '/pattern1|pattern2/{print $1}' | xargs kubectl delete -n mynamespace pod
```
@ -292,9 +292,9 @@ kubectl logs -f my-pod # Fait défiler (stream) les
kubectl logs -f my-pod -c my-container # Fait défiler (stream) les logs d'un conteneur particulier du pod (stdout, cas d'un pod multi-conteneurs)
kubectl logs -f -l name=myLabel --all-containers # Fait défiler (stream) les logs de tous les pods ayant le label name=myLabel (stdout)
kubectl run -i --tty busybox --image=busybox -- sh # Exécute un pod comme un shell interactif
kubectl run nginx --image=nginx --restart=Never -n
mynamespace # Run pod nginx in a specific namespace
kubectl run nginx --image=nginx --restart=Never # Run pod nginx and write its spec into a file called pod.yaml
kubectl run nginx --image=nginx --restart=Never -n
mynamespace # Exécute le pod nginx dans un namespace spécifique
kubectl run nginx --image=nginx --restart=Never # Simule l'exécution du pod nginx et écrit sa spécification dans un fichier pod.yaml
--dry-run -o yaml > pod.yaml
kubectl attach my-pod -i # Attache à un conteneur en cours d'exécution
@ -340,7 +340,7 @@ kubectl api-resources --api-group=extensions # Toutes les ressources dans le gro
### Formattage de l'affichage
Pour afficher les détails sur votre terminal dans un format spécifique, vous pouvez utiliser une des options `-o` ou `--output` avec les commandes `kubectl` qui les prennent en charge.
Pour afficher les détails sur votre terminal dans un format spécifique, utilisez l'option `-o` (ou `--output`) avec les commandes `kubectl` qui la prend en charge.
Format d'affichage | Description
--------------| -----------
@ -353,6 +353,21 @@ Format d'affichage | Description
`-o=wide` | Affiche dans le format texte avec toute information supplémentaire, et pour des pods, le nom du noeud est inclus
`-o=yaml` | Affiche un objet de l'API formaté en YAML
Exemples utilisant `-o=custom-columns` :
```bash
# Toutes les images s'exécutant dans un cluster
kubectl get pods -A -o=custom-columns='DATA:spec.containers[*].image'
# Toutes les images excepté "k8s.gcr.io/coredns:1.6.2"
kubectl get pods -A -o=custom-columns='DATA:spec.containers[?(@.image!="k8s.gcr.io/coredns:1.6.2")].image'
# Tous les champs dans metadata quel que soit leur nom
kubectl get pods -A -o=custom-columns='DATA:metadata.*'
```
Plus d'exemples dans la [documentation de référence](/fr/docs/reference/kubectl/overview/#colonnes-personnalisées) de kubectl.
### Verbosité de l'affichage de Kubectl et débogage
La verbosité de Kubectl est contrôlée par une des options `-v` ou `--v` suivie d'un entier représentant le niveau de log. Les conventions générales de logging de Kubernetes et les niveaux de log associés sont décrits [ici](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-instrumentation/logging.md).

63
content/fr/docs/reference/kubectl/conventions.md
View File

@ -16,7 +16,6 @@ Pour une sortie stable dans un script :
* Demandez un des formats de sortie orienté machine, comme `-o name`, `-o json`, `-o yaml`, `-o go-template` ou `-o jsonpath`.
* Spécifiez complètement la version. Par exemple, `jobs.v1.batch/monjob`. Cela va assurer que kubectl n'utilise pas sa version par défaut, qui risque d'évoluer avec le temps.
* Utilisez le flag `--generator` pour coller à un comportement spécifique lorsque vous utilisez les commandes basées sur un générateur, comme `kubectl run` ou `kubectl expose`.
* Ne vous basez pas sur un contexte, des préférences ou tout autre état implicite.
## Bonnes pratiques
@ -26,48 +25,34 @@ Pour une sortie stable dans un script :
Pour que `kubectl run` satisfasse l'infrastructure as code :
* Taggez les images avec un tag spécifique à une version et n'utilisez pas ce tag pour une nouvelle version. Par exemple, utilisez `:v1234`, `v1.2.3`, `r03062016-1-4`, plutôt que `:latest` (Pour plus d'informations, voir [Bonnes pratiques pour la configuration](/docs/concepts/configuration/overview/#container-images)).
* Capturez les paramètres dans un script enregistré, ou tout au moins utilisez `--record` pour annoter les objets créés avec la ligne de commande correspondante pour une image peu paramétrée.
* Capturez le script pour une image fortement paramétrée.
* Passez à des fichiers de configuration enregistrés dans un système de contrôle de source pour des fonctionnalités désirées mais non exprimables avec des flags de `kubectl run`.
* Collez à une version spécifique de [générateur](#generators), comme `kubectl run --generator=deployment/v1beta1`.
Vous pouvez utiliser l'option `--dry-run` pour prévisualiser l'objet qui serait envoyé à votre cluster, sans réellement l'envoyer.
{{< note >}}
Tous les générateurs `kubectl` sont dépréciés. Voir la documentation de Kubernetes v1.17 pour une [liste](https://v1-17.docs.kubernetes.io/fr/docs/reference/kubectl/conventions/#g%C3%A9n%C3%A9rateurs) de générateurs et comment ils étaient utilisés.
{{< /note >}}
#### Générateurs
Vous pouvez créer les ressources suivantes en utilisant `kubectl run` avec le flag `--generator` :
| Ressource | groupe api | commande kubectl |
|-----------------------------------|--------------------|---------------------------------------------------|
| Pod | v1 | `kubectl run --generator=run-pod/v1` |
| Replication controller (déprécié) | v1 | `kubectl run --generator=run/v1` |
| Deployment (déprécié) | extensions/v1beta1 | `kubectl run --generator=deployment/v1beta1` |
| Deployment (déprécié) | apps/v1beta1 | `kubectl run --generator=deployment/apps.v1beta1` |
| Job (déprécié) | batch/v1 | `kubectl run --generator=job/v1` |
| CronJob (déprécié) | batch/v1beta1 | `kubectl run --generator=cronjob/v1beta1` |
| CronJob (déprécié) | batch/v2alpha1 | `kubectl run --generator=cronjob/v2alpha1` |
{{< note >}}
`kubectl run --generator` sauf pour `run-pod/v1` est déprécié depuis v1.12.
{{< /note >}}
Si vous n'indiquez pas de flag de générateur, d'autres flags vous demandent d'utiliser un générateur spécifique. La table suivante liste les flags qui vous forcent à préciser un générateur spécifique, selon la version du cluster :
| Ressource générée | Cluster v1.4 et suivants | Cluster v1.3 | Cluster v1.2 | Cluster v1.1 et précédents |
|:----------------------:|--------------------------|-----------------------|--------------------------------------------|--------------------------------------------|
| Pod | `--restart=Never` | `--restart=Never` | `--generator=run-pod/v1` | `--restart=OnFailure` OU `--restart=Never` |
| Replication Controller | `--generator=run/v1` | `--generator=run/v1` | `--generator=run/v1` | `--restart=Always` |
| Deployment | `--restart=Always` | `--restart=Always` | `--restart=Always` | N/A |
| Job | `--restart=OnFailure` | `--restart=OnFailure` | `--restart=OnFailure` OU `--restart=Never` | N/A |
| Cron Job | `--schedule=<cron>` | N/A | N/A | N/A |
{{< note >}}
Ces flags utilisent un générateur par défaut uniquement lorsque vous n'avez utilisé aucun flag.
Cela veut dire que lorsque vous combinez `--generator` avec d'autres flags, le générateur que vous avez spécifié plus tard ne change pas. Par exemple, dans cluster v1.4, si vous spécifiez d'abord `--restart=Always`, un Deployment est créé ; si vous spécifiez ensuite `--restart=Always` et `--generator=run/v1`, alors un Replication Controller sera créé.
Ceci vous permet de coller à un comportement spécifique avec le générateur, même si le générateur par défaut est changé par la suite.
{{< /note >}}
Les flags définissent le générateur dans l'ordre suivant : d'abord le flag `--schedule`, puis le flag `--restart`, et finalement le flag `--generator`.
Pour vérifier la ressource qui a été finalement créée, utilisez le flag `--dry-run`, qui fournit l'objet qui sera soumis au cluster.
Vous pouvez générer les ressources suivantes avec une commande kubectl, `kubectl create --dry-run -o yaml`:
```
clusterrole Crée un ClusterRole.
clusterrolebinding Crée un ClusterRoleBinding pour un ClusterRole particulier.
configmap Crée une configmap à partir d'un fichier local, un répertoire ou une valeur litérale.
cronjob Crée un cronjob avec le nom spécifié.
deployment Crée un deployment avec le nom spécifié.
job Crée un job avec le nom spécifié.
namespace Crée un namespace avec le nom spécifié.
poddisruptionbudget Crée un pod disruption budget avec le nom spécifié.
priorityclass Crée une priorityclass avec le nom spécifié.
quota Crée un quota avec le nom spécifié.
role Crée un role avec une unique règle.
rolebinding Crée un RoleBinding pour un Role ou ClusterRole particulier.
secret Crée un secret en utilisant la sous-commande spécifiée.
service Crée un service en utilisant la sous-commande spécifiée.
serviceaccount Crée un service account avec le nom spécifié.
```
### `kubectl apply`

12
content/fr/docs/reference/kubectl/jsonpath.md
View File

@ -71,10 +71,10 @@ Fonction | Description | Exemple
--------------------|----------------------------|-----------------------------------------------------------------|------------------
`text` | le texte en clair | `le type est {.kind}` | `le type est List`
`@` | l'objet courant | `{@}` | identique à l'entrée
`.` ou `[]` | opérateur fils | `{.kind}` ou `{['kind']}` | `List`
`.` ou `[]` | opérateur fils | `{.kind}`, `{['kind']}` ou `{['name\.type']}` | `List`
`..` | descente récursive | `{..name}` | `127.0.0.1 127.0.0.2 myself e2e`
`*` | joker. Tous les objets | `{.items[*].metadata.name}` | `[127.0.0.1 127.0.0.2]`
`[start:end :step]` | opérateur d'indice | `{.users[0].name}` | `myself`
`[start:end:step]` | opérateur d'indice | `{.users[0].name}` | `myself`
`[,]` | opérateur d'union | `{.items[*]['metadata.name', 'status.capacity']}` | `127.0.0.1 127.0.0.2 map[cpu:4] map[cpu:8]`
`?()` | filtre | `{.users[?(@.name=="e2e")].user.password}` | `secret`
`range`, `end` | itération de liste | `{range .items[*]}[{.metadata.name}, {.status.capacity}] {end}` | `[127.0.0.1, map[cpu:4]] [127.0.0.2, map[cpu:8]]`
@ -87,14 +87,18 @@ kubectl get pods -o json
kubectl get pods -o=jsonpath='{@}'
kubectl get pods -o=jsonpath='{.items[0]}'
kubectl get pods -o=jsonpath='{.items[0].metadata.name}'
kubectl get pods -o=jsonpath="{.items[*]['metadata.name', 'status.capacity']}"
kubectl get pods -o=jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.status.startTime}{"\n"}{end}'
```
{{< note >}}
Sous Windows, vous devez utiliser des guillemets _doubles_ autour des modèles JSONPath qui contiennent des espaces (et non des guillemets simples comme ci-dessus pour bash). Ceci entraîne que vous devez utiliser un guillemet simple ou un double guillemet échappé autour des chaînes litérales dans le modèle. Par exemple :
```cmd
C:\> kubectl get pods -o=jsonpath="{range .items[*]}{.metadata.name}{'\t'}{.status.startTime}{'\n'}{end}"
C:\> kubectl get pods -o=jsonpath="{range .items[*]}{.metadata.name}{\"\t\"}{.status.startTime}{\"\n\"}{end}"
kubectl get pods -o=jsonpath="{range .items[*]}{.metadata.name}{'\t'}{.status.startTime}{'\n'}{end}"
kubectl get pods -o=jsonpath="{range .items[*]}{.metadata.name}{\"\t\"}{.status.startTime}{\"\n\"}{end}"
```
{{< /note >}}
{{% /capture %}}

3
content/fr/docs/reference/kubectl/kubectl.md
View File

@ -510,6 +510,7 @@ kubectl [flags]
{{% capture seealso %}}
* [kubectl alpha](/docs/reference/generated/kubectl/kubectl-commands#alpha) - Commandes pour fonctionnalités alpha
* [kubectl annotate](/docs/reference/generated/kubectl/kubectl-commands#annotate) - Met à jour les annotations d'une ressource
* [kubectl api-resources](/docs/reference/generated/kubectl/kubectl-commands#api-resources) - Affiche les ressources de l'API prises en charge sur le serveur
* [kubectl api-versions](/docs/reference/generated/kubectl/kubectl-commands#api-versions) - Affiche les versions de l'API prises en charge sur le serveur, sous la forme "groupe/version"
@ -545,7 +546,7 @@ kubectl [flags]
* [kubectl replace](/docs/reference/generated/kubectl/kubectl-commands#replace) - Remplace une ressource par fichier ou stdin
* [kubectl rollout](/docs/reference/generated/kubectl/kubectl-commands#rollout) - Gère le rollout d'une ressource
* [kubectl run](/docs/reference/generated/kubectl/kubectl-commands#run) - Exécute une image donnée dans le cluster
* [kubectl scale](/docs/reference/generated/kubectl/kubectl-commands#scale) - Définit une nouvelle taille pour un Deployment, ReplicaSet, Replication Controller, ou Job
* [kubectl scale](/docs/reference/generated/kubectl/kubectl-commands#scale) - Définit une nouvelle taille pour un Deployment, ReplicaSet ou Replication Controller
* [kubectl set](/docs/reference/generated/kubectl/kubectl-commands#set) - Définit des fonctionnalités spécifiques sur des objets
* [kubectl taint](/docs/reference/generated/kubectl/kubectl-commands#taint) - Met à jour les marques (taints) sur un ou plusieurs nœuds
* [kubectl top](/docs/reference/generated/kubectl/kubectl-commands#top) - Affiche l'utilisation de ressources matérielles (CPU/Memory/Storage)

71
content/fr/docs/reference/kubectl/overview.md
View File

@ -9,7 +9,7 @@ card:
---
{{% capture overview %}}
Kubectl est une interface en ligne de commande qui permet d'exécuter des commandes sur des clusters Kubernetes. `kubectl` recherche un fichier appelé config dans le répertoire $HOME/.kube. Vous pouvez spécifier d'autres fichiers [kubeconfig](https://kube
Kubectl est un outil en ligne de commande pour contrôler des clusters Kubernetes. `kubectl` recherche un fichier appelé config dans le répertoire $HOME/.kube. Vous pouvez spécifier d'autres fichiers [kubeconfig](https://kube
rnetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig/) en définissant la variable d'environnement KUBECONFIG ou en utilisant le paramètre [`--kubeconfig`](https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig/).
Cet aperçu couvre la syntaxe `kubectl`, décrit les opérations et fournit des exemples classiques. Pour des détails sur chaque commande, incluant toutes les options et sous-commandes autorisées, voir la documentation de référence de [kubectl](/docs/reference/generated/kubectl/kubectl-commands/). Pour des instructions d'installation, voir [installer kubectl](/docs/tasks/kubectl/install/).
@ -67,34 +67,51 @@ Si vous avez besoin d'aide, exécutez `kubectl help` depuis la fenêtre de termi
Le tableau suivant inclut une courte description et la syntaxe générale pour chaque opération `kubectl` :
Opération | Syntaxe | Description
-------------------- | -------------------- | --------------------
Opération | Syntaxe | Description
----------------| ---------------------------------------------------------------------------------------------------------------------------------------------------------| --------------------
`alpha` | `kubectl alpha SOUS-COMMANDE [flags]` | Liste les commandes disponibles qui correspondent à des fonctionnalités alpha, qui ne sont pas activées par défaut dans les clusters Kubernetes.
`annotate` | <code>kubectl annotate (-f FICHIER &#124; TYPE NOM &#124; TYPE/NOM) CLE_1=VAL_1 ... CLE_N=VAL_N [--overwrite] [--all] [--resource-version=version] [flags]</code> | Ajoute ou modifie les annotations d'une ou plusieurs ressources.
`api-resources` | `kubectl api-resources [flags]` | Liste les ressources d'API disponibles.
`api-versions` | `kubectl api-versions [flags]` | Liste les versions d'API disponibles.
`apply` | `kubectl apply -f FICHIER [flags]` | Applique un changement de configuration à une ressource depuis un fichier ou stdin.
`attach` | `kubectl attach POD -c CONTENEUR [-i] [-t] [flags]` | Attache à un conteneur en cours d'exécution soit pour voir la sortie standard soit pour interagir avec le conteneur (stdin).
`auth` | `kubectl auth [flags] [options]` | Inspecte les autorisations.
`autoscale` | <code>kubectl autoscale (-f FICHIER &#124; TYPE NOM &#124; TYPE/NOM) [--min=MINPODS] --max=MAXPODS [--cpu-percent=CPU] [flags]</code> | Scale automatiquement l'ensemble des pods gérés par un replication controller.
`certificate` | `kubectl certificate SOUS-COMMANDE [options]` | Modifie les ressources de type certificat.
`cluster-info` | `kubectl cluster-info [flags]` | Affiche les informations des endpoints du master et des services du cluster.
`completion` | `kubectl completion SHELL [options]` | Affiche le code de complétion pour le shell spécifié (bash ou zsh).
`config` | `kubectl config SOUS-COMMANDE [flags]` | Modifie les fichiers kubeconfig. Voir les sous-commandes individuelles pour plus de détails.
`convert` | `kubectl convert -f FICHIER [options]` | Convertit des fichiers de configuration entre différentes versions d'API. Les formats YAML et JSON sont acceptés.
`cordon` | `kubectl cordon NOEUD [options]` | Marque un nœud comme non programmable.
`cp` | `kubectl cp <ficher-src> <fichier-dest> [options]` | Copie des fichiers et des répertoires vers et depuis des conteneurs.
`create` | `kubectl create -f FICHIER [flags]` | Crée une ou plusieurs ressources depuis un fichier ou stdin.
`delete` | <code>kubectl delete (-f FICHIER &#124; TYPE [NOM &#124; /NOM &#124; -l label &#124; --all]) [flags]</code> | Supprime des ressources soit depuis un fichier ou stdin, ou en indiquant des sélecteurs de label, des noms, des sélecteurs de ressources ou des ressources.
`describe` | <code>kubectl describe (-f FICHIER &#124; TYPE [PREFIXE_NOM &#124; /NOM &#124; -l label]) [flags]</code> | Affiche l'état détaillé d'une ou plusieurs ressources.
`diff` | `kubectl diff -f FICHIER [flags]` | Diff un fichier ou stdin par rapport à la configuration en cours (**BETA**)
`diff` | `kubectl diff -f FICHIER [flags]` | Diff un fichier ou stdin par rapport à la configuration en cours
`drain` | `kubectl drain NOEUD [options]` | Vide un nœud en préparation de sa mise en maintenance.
`edit` | <code>kubectl edit (-f FICHIER &#124; TYPE NOM &#124; TYPE/NOM) [flags]</code> | Édite et met à jour la définition d'une ou plusieurs ressources sur le serveur en utilisant l'éditeur par défaut.
`exec` | `kubectl exec POD [-c CONTENEUR] [-i] [-t] [flags] [-- COMMANDE [args...]]` | Exécute une commande à l'intérieur d'un conteneur dans un pod.
`explain` | `kubectl explain [--recursive=false] [flags]` | Obtient des informations sur différentes ressources. Par exemple pods, nœuds, services, etc.
`expose` | <code>kubectl expose (-f FICHIER &#124; TYPE NOM &#124; TYPE/NOM) [--port=port] [--protocol=TCP&#124;UDP] [--target-port=nombre-ou-nom] [--name=nom] [--external-ip=ip-externe-ou-service] [--type=type] [flags]</code> | Expose un replication controller, service ou pod comme un nouveau service Kubernetes.
`get` | <code>kubectl get (-f FICHIER &#124; TYPE [NOM &#124; /NOM &#124; -l label]) [--watch] [--sort-by=CHAMP] [[-o &#124; --output]=FORMAT_AFFICHAGE] [flags]</code> | Liste une ou plusieurs ressources.
`kustomize` | `kubectl kustomize <répertoire> [flags] [options]` | Liste un ensemble de ressources d'API généré à partir d'instructions d'un fichier kustomization.yaml. Le paramètre doit être le chemin d'un répertoire contenant ce fichier, ou l'URL d'un dépôt git incluant un suffixe de chemin par rapport à la racine du dépôt.
`label` | <code>kubectl label (-f FICHIER &#124; TYPE NOM &#124; TYPE/NOM) CLE_1=VAL_1 ... CLE_N=VAL_N [--overwrite] [--all] [--resource-version=version] [flags]</code> | Ajoute ou met à jour les labels d'une ou plusieurs ressources.
`logs` | `kubectl logs POD [-c CONTENEUR] [--follow] [flags]` | Affiche les logs d'un conteneur dans un pod.
`options` | `kubectl options` | Liste des options globales, s'appliquant à toutes commandes.
`patch` | <code>kubectl patch (-f FICHIER &#124; TYPE NOM &#124; TYPE/NOM) --patch PATCH [flags]</code> | Met à jour un ou plusieurs champs d'une resource en utilisant le processus de merge patch stratégique.
`plugin` | `kubectl plugin [flags] [options]` | Fournit des utilitaires pour interagir avec des plugins.
`port-forward` | `kubectl port-forward POD [PORT_LOCAL:]PORT_DISTANT [...[PORT_LOCAL_N:]PORT_DISTANT_N] [flags]` | Transfère un ou plusieurs ports locaux vers un pod.
`proxy` | `kubectl proxy [--port=PORT] [--www=static-dir] [--www-prefix=prefix] [--api-prefix=prefix] [flags]` | Exécute un proxy vers un API server Kubernetes.
`replace` | `kubectl replace -f FICHIER` | Remplace une ressource depuis un fichier ou stdin.
`rolling-update`| <code>kubectl rolling-update ANCIEN_NOM_CONTROLEUR ([NOUVEAU_NOM_CONTROLEUR] --image=NOUVELLE_IMAGE_CONTENEUR &#124; -f NOUVELLE_SPEC_CONTROLEUR) [flags]</code> | Exécute un rolling update en remplaçant graduellement le replication controller indiqué et ses pods.
`run` | `kubectl run NOM --image=image [--env="cle=valeur"] [--port=port] [--replicas=replicas] [--dry-run=bool] [--overrides=inline-json] [flags]` | Exécute dans le cluster l'image indiquée.
`rollout` | `kubectl rollout SOUS-COMMANDE [options]` | Gère le rollout d'une ressource. Les types de ressources valides sont : deployments, daemonsets et statefulsets.
`run` | `kubectl run NOM --image=image [--env="cle=valeur"] [--port=port] [--replicas=replicas] [--dry-run=server&#124;client&#124;none] [--overrides=inline-json] [flags]` | Exécute dans le cluster l'image indiquée.
`scale` | <code>kubectl scale (-f FICHIER &#124; TYPE NOM &#124; TYPE/NOM) --replicas=QUANTITE [--resource-version=version] [--current-replicas=quantité] [flags]</code> | Met à jour la taille du replication controller indiqué.
`set` | `kubectl set SOUS-COMMANDE [options]` | Configure les ressources de l'application.
`taint` | `kubectl taint NOEUD NNOM CLE_1=VAL_1:EFFET_TAINT_1 ... CLE_N=VAL_N:EFFET_TAINT_N [options]` | Met à jour les marques (taints) d'un ou plusieurs nœuds.
`top` | `kubectl top [flags] [options]` | Affiche l'utilisation des ressources (CPU/Mémoire/Stockage).
`uncordon` | `kubectl uncordon NOEUD [options]` | Marque un noeud comme programmable.
`version` | `kubectl version [--client] [flags]` | Affiche la version de Kubernetes du serveur et du client.
`wait` | <code>kubectl wait ([-f FICHIER] &#124; ressource.groupe/ressource.nom &#124; ressource.groupe [(-l label &#124; --all)]) [--for=delete&#124;--for condition=available] [options]</code> | Expérimental : Attend un condition spécifique sur une ou plusieurs ressources.
Rappelez-vous : Pour tout savoir sur les opérations, voir la documentation de référence de [kubectl](/docs/user-guide/kubectl/).
@ -105,7 +122,8 @@ Le tableau suivant inclut la liste de tous les types de ressources pris en charg
(cette sortie peut être obtenue depuis `kubectl api-resources`, et correspond à Kubernetes 1.13.3.)
| Nom de la ressource | Noms abrégés | Groupe API | Par namespace | Genre de la ressource |
|---|---|---|---|---|
|---------------------|--------------|------------|---------------|-----------------------|
| `bindings` | | | true | Binding|
| `componentstatuses` | `cs` | | false | ComponentStatus |
| `configmaps` | `cm` | | true | ConfigMap |
| `endpoints` | `ep` | | true | Endpoints |
@ -150,6 +168,8 @@ Le tableau suivant inclut la liste de tous les types de ressources pris en charg
| `rolebindings` | | rbac.authorization.k8s.io | true | RoleBinding |
| `roles` | | rbac.authorization.k8s.io | true | Role |
| `priorityclasses` | `pc` | scheduling.k8s.io | false | PriorityClass |
| `csidrivers` | | storage.k8s.io | false | CSIDriver |
| `csinodes` | | storage.k8s.io | false | CSINode |
| `storageclasses` | `sc` | storage.k8s.io | false | StorageClass |
| `volumeattachments` | | storage.k8s.io | false | VolumeAttachment |
@ -242,8 +262,8 @@ kubectl get pods <nom-pod> --server-print=false
La sortie ressemble à :
```shell
NAME READY STATUS RESTARTS AGE
nom-pod 1/1 Running 0 1m
NAME AGE
nom-pod 1m
```
### Ordonner les listes d'objets
@ -297,8 +317,8 @@ $ kubectl get replicationcontroller <nom-rc>
# Liste ensemble tous les replication controller et les services dans le format de sortie texte.
$ kubectl get rc,services
# Liste tous les daemon sets, dont ceux non initialisés, dans le format de sortie texte.
$ kubectl get ds --include-uninitialized
# Liste tous les daemon sets dans le format de sortie texte.
kubectl get ds
# Liste tous les pods s'exécutant sur le nœud serveur01
$ kubectl get pods --field-selector=spec.nodeName=serveur01
@ -317,8 +337,8 @@ $ kubectl describe pods/<nom-pod>
# Rappelez-vous : les noms des pods étant créés par un replication controller sont préfixés par le nom du replication controller.
$ kubectl describe pods <nom-rc>
# Décrit tous les pods, sans inclure les non initialisés
$ kubectl describe pods --include-uninitialized=false
# Décrit tous les pods
$ kubectl describe pods
```
{{< note >}}
@ -332,11 +352,8 @@ Vous pouvez utiliser les options `-w` ou `--watch` pour initier l'écoute des mo
# Supprime un pod en utilisant le type et le nom spécifiés dans le fichier pod.yaml.
$ kubectl delete -f pod.yaml
# Supprime tous les pods et services ayant le label name=<label-name>.
$ kubectl delete pods,services -l name=<label-name>
# Supprime tous les pods et services ayant le label name=<label-name>, en incluant les non initialisés.
$ kubectl delete pods,services -l name=<label-name> --include-uninitialized
# Supprime tous les pods et services ayant le label <clé-label>=<valeur-label>
$ kubectl delete pods,services -l <clé-label>=<valeur-label>
# Supprime tous les pods, en incluant les non initialisés.
$ kubectl delete pods --all
@ -346,13 +363,13 @@ $ kubectl delete pods --all
```shell
# Affiche la sortie de la commande 'date' depuis le pod <nom-pod>. Par défaut, la sortie se fait depuis le premier conteneur.
$ kubectl exec <nom-pod> date
$ kubectl exec <nom-pod> -- date
# Affiche la sortie de la commande 'date' depuis le conteneur <nom-conteneur> du pod <nom-pod>.
$ kubectl exec <nom-pod> -c <nom-conteneur> date
$ kubectl exec <nom-pod> -c <nom-conteneur> -- date
# Obtient un TTY interactif et exécute /bin/bash depuis le pod <nom-pod>. Par défaut, la sortie se fait depuis le premier conteneur.
$ kubectl exec -ti <nom-pod> /bin/bash
$ kubectl exec -ti <nom-pod> -- /bin/bash
```
`kubectl logs` - Affiche les logs d'un conteneur dans un pod.
@ -365,6 +382,16 @@ $ kubectl logs <nom-pod>
$ kubectl logs -f <nom-pod>
```
`kubectl diff` - Affiche un diff des mises à jour proposées au cluster.
```shell
# Diff les ressources présentes dans "pod.json".
kubectl diff -f pod.json
# Diff les ressources présentes dans le fichier lu sur l'entrée standard.
cat service.yaml | kubectl diff -f -
```
## Exemples : Créer et utiliser des plugins
Utilisez les exemples suivants pour vous familiariser avec l'écriture et l'utilisation de plugins `kubectl` :
@ -428,7 +455,7 @@ $ cat ./kubectl-whoami
# ce plugin utilise la commande `kubectl config` pour afficher
# l'information sur l'utilisateur courant, en se basant sur
# le contexte couramment sélectionné
kubectl config view --template='{{ range .contexts }}{{ if eq .name "'$(kubectl config current-context)'" }}Current user: {{ .context.user }}{{ end }}{{ end }}'
kubectl config view --template='{{ range .contexts }}{{ if eq .name "'$(kubectl config current-context)'" }}Current user: {{ printf "%s\n" .context.user }}{{ end }}{{ end }}'
```
Exécuter le plugin ci-dessus vous donne une sortie contenant l'utilisateur du contexte couramment sélectionné dans votre fichier KUBECONFIG :