Dokuwiki

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Kubernetes ======
  * [[http://kubernetes.io/|Site Officiel]]
  * [[https://docs.kubernetic.com/|Autre doc]]
  * [[https://kubernetes.io/docs/user-guide/kubectl-cheatsheet/|Cheatsheet]]
  * [[systeme:docker|Docker]]

  * [[https://docs.helm.sh/using_helm/#installing-helm|Helm]]

  * [[https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands|Toutes les commandes et options]]

  * https://labs.play-with-docker.com
  * https://labs.play-with-k8s.com
===== Autres =====
  * [[http://kubernetes.io/docs/user-guide/ingress/|Ingress]]
  * [[http://kubernetes.io/docs/admin/daemons/|Daemons]]
  * [[http://kubernetes.io/docs/user-guide/images/|Images]]
  * [[http://kubernetes.io/docs/user-guide/jobs/|Jobs]]
  * [[http://kubernetes.io/docs/user-guide/scheduled-jobs/|Scheduled Jobs]]
  * [[http://kubernetes.io/docs/user-guide/labels/|Labels]]
  * [[http://kubernetes.io/docs/user-guide/namespaces/|Namespaces]]
  * [[http://kubernetes.io/docs/user-guide/networkpolicies/|Network Policies]]
  * [[http://kubernetes.io/docs/admin/node/|Node]]
  * [[http://kubernetes.io/docs/user-guide/persistent-volumes/|Persistent Volumes]]
  * [[http://kubernetes.io/docs/user-guide/volumes/|Volumes]]
  * [[http://kubernetes.io/docs/user-guide/ui/|Dashboard]]
  * [[http://kubernetes.io/docs/tasks/configure-pod-container/define-environment-variable-container/|Environnement dans un conteneur]]
  * [[http://kubernetes.io/docs/tasks/configure-pod-container/define-command-argument-container/|Commande dans un conteneur]]
  * [[http://kubernetes.io/docs/tasks/configure-pod-container/assign-cpu-ram-container/|Limiter les ressources pour un conteneur]]
  * [[http://kubernetes.io/docs/admin/resourcequota/|Quota sur les ressources 1]] + [[http://kubernetes.io/docs/admin/resourcequota/walkthrough/|Quota sur les ressources 2]]
  * [[http://kubernetes.io/docs/tasks/administer-cluster/assign-pods-nodes/|Assigner un pod à des nœuds]]
  * [[http://kubernetes.io/docs/user-guide/liveness/|POD health]]
  * [[http://kubernetes.io/docs/user-guide/monitoring/|Monitoring]]
  * [[http://kubernetes.io/docs/admin/cluster-components/|Composants Kubernetes]]
  * [[http://kubernetes.io/docs/admin/dns/|DNS]] + [[https://coreos.com/kubernetes/docs/latest/deploy-addons.html|kube-dns]]

===== Affichage =====
Repérer le champ à afficher en yaml, puis isoler le pour l'afficher :
<xtermrtf>
$ kubectl get pod wordpress-2713623249-d46ky -o yaml
$ kubectl get -o template pod wordpress-2713623249-d46ky --template={{.status.podIP}}
</xtermrtf>
===== Commandes =====
==== kubectl ====
  * [[http://kubernetes.io/docs/user-guide/kubectl/|Gère le cluster Kubernetes]]

==== kubectl annotate ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_annotate/|Met une annotation sur une ressource]] :
<xtermrtf>
# Update pod 'foo' with the annotation 'description' and the value 'my frontend'.
# If the same annotation is set multiple times, only the last value will be applied
$ kubectl annotate pods foo description='my frontend'

# Update a pod identified by type and name in "pod.json"
$ kubectl annotate -f pod.json description='my frontend'

# Update pod 'foo' with the annotation 'description' and the value 'my frontend running nginx', overwriting any existing value.
$ kubectl annotate --overwrite pods foo description='my frontend running nginx'

# Update all pods in the namespace
$ kubectl annotate pods --all description='my frontend running nginx'

# Update pod 'foo' only if the resource is unchanged from version 1.
$ kubectl annotate pods foo description='my frontend running nginx' --resource-version=1

# Update pod 'foo' by removing an annotation named 'description' if it exists.
# Does not require the --overwrite flag.
$ kubectl annotate pods foo description-
</xtermrtf>

<note>
  * http://kubernetes.io/docs/user-guide/annotations/
</note>

==== kubectl api-versions ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_api-versions/|Affiche les différentes API]] :
<xtermrtf>
$ kubectl api-versions
autoscaling/v1
batch/v1
extensions/v1beta1
v1
</xtermrtf>

==== kubectl apply ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_apply/|Applique les changements sur les pods]] :
<xtermrtf>
$ kubectl apply -f ./myapp.yaml
</xtermrtf>

On peut prendre en compte également tous les fichiers d'un répertoire de façon récursive :
<xtermrtf>
$ kubectl apply -R -f ./directory
</xtermrtf>

==== kubectl attach ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_attach/|S'attacher à un conteneur qui est démarré]] :
<xtermrtf>
# Get output from running pod 123456-7890, using the first container by default
$ kubectl attach 123456-7890

# Get output from ruby-container from pod 123456-7890
$ kubectl attach 123456-7890 -c ruby-container

# Switch to raw terminal mode, sends stdin to 'bash' in ruby-container from pod 123456-7890
# and sends stdout/stderr from 'bash' back to the client
$ kubectl attach 123456-7890 -c ruby-container -i -t
</xtermrtf>

==== kubectl autoscale ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_autoscale/|Auto-scale un Deployment, ReplicaSet, ou ReplicationController]] :
<xtermrtf>
# Auto scale a deployment "foo", with the number of pods between 2 and 10, target CPU utilization specified so a default autoscaling policy will be used:
$ kubectl autoscale deployment foo --min=2 --max=10

# Auto scale a replication controller "foo", with the number of pods between 1 and 5, target CPU utilization at 80%:
$ kubectl autoscale rc foo --max=5 --cpu-percent=80
</xtermrtf>

<note>
  * http://kubernetes.io/docs/user-guide/horizontal-pod-autoscaling/
</note>

==== kubectl cluster-info ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_cluster-info/|Affiche les informations du cluster]] :
<xtermrtf>
$ kubectl cluster-info
</xtermrtf>

==== kubectl config ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_config/|Permet de modifier des fichiers kubeconfig]].

=== kubectl config current-context ===
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_config_current-context/|Affiche le contexte courant]].

=== kubectl config set-cluster ===
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_config_set-cluster/|Définit une entrée cluster dans kubeconfig]].

=== kubectl config set-context ===
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_config_set-context/|Définit un contexte dans kubeconfig]].

=== kubectl config set-credentials ===
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_config_set-credentials/|Définit un utilisateur dans kubeconfig]].

=== kubectl config set ===
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_config_set/|Définit une valeur dans kubeconfig]].

=== kubectl config unset ===
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_config_unset/|Supprime une valeur dans kubeconfig]].

=== kubectl config use-context ===
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_config_use-context/|Définit le contexte à utiliser dans kubeconfig]].

=== kubectl config view ===
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_config_use-context/|Affiche la configuration de kubeconfig]].

==== kubectl convert ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_convert/|Convertit des fichiers entre différentes versions d'API]] :
<xtermrtf>
# Convert 'pod.yaml' to latest version and print to stdout.
$ kubectl convert -f pod.yaml

# Convert the live state of the resource specified by 'pod.yaml' to the latest version
# and print to stdout in json format.
$ kubectl convert -f pod.yaml --local -o json

# Convert all files under current directory to latest version and create them all.
$ kubectl convert -f . | kubectl create -f -
</xtermrtf>

==== kubectl cordon ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_cordon/|Empêche de nouveaux POD d'être lancé sur le noeud en question mais ne détruit pas les pods courant]] :
<xtermrtf>
$ kubectl cordon NODE
</xtermrtf>


==== kubectl create ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_create/|Crée un nouvelle ressource]] :
<xtermrtf>
# Create a pod using the data in pod.json.
$ kubectl create -f ./pod.json

# Recursive mode
$ kubectl create -R -f ./mydirectory

# Create a pod based on the JSON passed into stdin.
$ cat pod.json | kubectl create -f -
</xtermrtf>

<note>
  * http://kubernetes.io/docs/user-guide/deployments/
</note>

=== kubectl create configmap ===
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_create_configmap/|Crée une entrée configmap]] :
<xtermrtf>
# Create a new configmap named my-config with keys for each file in folder bar
$ kubectl create configmap my-config --from-file=path/to/bar

# Create a new configmap named my-config with specified keys instead of names on disk
$ kubectl create configmap my-config --from-file=key1=/path/to/bar/file1.txt --from-file=key2=/path/to/bar/file2.txt

# Create a new configmap named my-config with key1=config1 and key2=config2
$ kubectl create configmap my-config --from-literal=key1=config1 --from-literal=key2=config2
</xtermrtf>

Modifier une config map :
<xtermrtf>
$ kubectl create configmap nginx-lb-config --from-file=nginx-lb.configmap --dry-run -o yaml | kubectl replace configmap nginx-lb-config -f -
</xtermrtf>

Exemple de configmap :
<code>
apiVersion: v1
kind: ConfigMap
metadata:
 Name: example-configmap
data:
 # property-like keys
 game-properties-file-name: game.properties
 ui-properties-file-name: ui.properties
 # file-like keys
 game.properties: |
   enemies=aliens
   lives=3
   enemies.cheat=true
   enemies.cheat.level=noGoodRotten
   secret.code.passphrase=UUDDLRLRBABAS
   secret.code.allowed=true
   secret.code.lives=30
 ui.properties: |
   color.good=purple
   color.bad=yellow
   allow.textmode=true
   how.nice.to.look=fairlyNice
</code>

Exemple de création qui utilisera le configmap définit au-dessus :
<code>
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
 name: configmap-example-deployment
 labels:
   name: configmap-example-deployment
spec:
 replicas: 1
 selector:
   matchLabels:
     name: configmap-example
 template:
   metadata:
     labels:
       name: configmap-example
   spec:
     containers:
     - name: game-container
       image: imaginarygame
       command: [ "game-server", "--config-dir=/etc/game/cfg" ]
       env:
       # consume the property-like keys in environment variables
       - name: GAME_PROPERTIES_NAME
         valueFrom:
           configMapKeyRef:
             name: example-configmap
             key: game-properties-file-name
       - name: UI_PROPERTIES_NAME
         valueFrom:
           configMapKeyRef:
             name: example-configmap
             key: ui-properties-file-name
       volumeMounts:
       - name: config-volume
         mountPath: /etc/game
     volumes:
     # consume the file-like keys of the configmap via volume plugin
     - name: config-volume
       configMap:
         name: example-configmap
         items:
         - key: ui.properties
           path: cfg/ui.properties
        - key: game.properties
          path: cfg/game.properties
     restartPolicy: Never 
</code>

=== kubectl create namespace ===
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_create_namespace/|Crée un namespace avec un nom spécifique]] :
<xtermrtf>
$ kubectl create namespace my-namespace
</xtermrtf>

=== kubectl create serviceaccount ===
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_create_serviceaccount/|Crée un serviceaccount]] :
<xtermrtf>
$ kubectl create serviceaccount my-service-account
</xtermrtf>

<note>
  * http://kubernetes.io/docs/user-guide/service-accounts/
  * http://kubernetes.io/docs/admin/service-accounts-admin/
</note>

=== kubectl create secret ===
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_create_secret/|Crée un secret]].

<note>
  * http://kubernetes.io/docs/user-guide/secrets/
</note>

== kubectl create secret docker-registry ==
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_create_secret_docker-registry/|Crée un secret pour un registry docker]] :
<xtermrtf>
$ kubectl create secret docker-registry my-secret --docker-server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL
</xtermrtf>

== kubectl create secret generic ==
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_create_secret_generic/|Crée un secret à partir d'un dossier, fichier ou valeur]] :
<xtermrtf>
# Create a new secret named my-secret with keys for each file in folder bar
$ kubectl create secret generic my-secret --from-file=path/to/bar

# Create a new secret named my-secret with specified keys instead of names on disk
$ kubectl create secret generic my-secret --from-file=ssh-privatekey=~/.ssh/id_rsa --from-file=ssh-publickey=~/.ssh/id_rsa.pub

# Create a new secret named my-secret with key1=supersecret and key2=topsecret
$ kubectl create secret generic my-secret --from-literal=key1=supersecret --from-literal=key2=topsecret
</xtermrtf>

==== kubectl delete ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_delete/|Supprime une ressource]] :
<xtermrtf>
# Delete a pod using the type and name specified in pod.json.
$ kubectl delete -f ./pod.json

# Delete a pod based on the type and name in the JSON passed into stdin.
$ cat pod.json | kubectl delete -f -

# Delete pods and services with same names "baz" and "foo"
$ kubectl delete pod,service baz foo

# Delete pods and services with label name=myLabel.
$ kubectl delete pods,services -l name=myLabel

# Delete a pod immediately (no graceful shutdown)
$ kubectl delete pod foo --now

# Delete a pod with UID 1234-56-7890-234234-456456.
$ kubectl delete pod 1234-56-7890-234234-456456

# Delete all pods
$ kubectl delete pods --all
</xtermrtf>

==== kubectl describe ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_decribe/|Décrit une ressource]] :
<xtermrtf>
# Describe a node
$ kubectl describe nodes kubernetes-minion-emt8.c.myproject.internal

# Describe a pod
$ kubectl describe pods/nginx

# Describe a pod identified by type and name in "pod.json"
$ kubectl describe -f pod.json

# Describe all pods
$ kubectl describe pods

# Describe pods by label name=myLabel
$ kubectl describe po -l name=myLabel

# Describe all pods managed by the 'frontend' replication controller (rc-created pods
# get the name of the rc as a prefix in the pod the name).
$ kubectl describe pods frontend
</xtermrtf>

==== kubectl drain ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_drain/|Bloque la création de nouveau pod puis supprime les pods du noeud]] :
<xtermrtf>
# Drain node "foo", even if there are pods not managed by a ReplicationController, ReplicaSet, Job, or DaemonSet on it.
$ kubectl drain foo --force

# As above, but abort if there are pods not managed by a ReplicationController, ReplicaSet, Job, or DaemonSet, and use a grace period of 15 minutes.
$ kubectl drain foo --grace-period=900
</xtermrtf>

==== kubectl edit ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_edit/|Edite la configuration d'une ressource]] :
<xtermrtf>
$ kubectl edit node k-node1
$ kubectl edit deployment nginx -o json
$ kubectl edit pod nginx-deployment-2644738339-826ks
$ kubectl edit svc/docker-registry --output-version=v1 -o json
</xtermrtf>

==== kubectl exec ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_exec/|Execute une commande dans un conteneur]] :
<xtermrtf>
$ kubectl exec nginx-2644738339-826ks -it -- bash
$ kubectl exec 123456-7890 -c ruby-container -i -t -- bash -il
</xtermrtf>

==== kubectl explain ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_explain/|Documente une ressource]] :
<xtermrtf>
# Get the documentation of the resource and its fields
$ kubectl explain pods

# Get the documentation of a specific field of a resource
$ kubectl explain pods.spec.containers
</xtermrtf>

==== kubectl expose ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_expose/|Déclare une ressource comme un nouveau service]] :
<xtermrtf>
# Create a service for a replicated nginx, which serves on port 80 and connects to the containers on port 8000.
$ kubectl expose rc nginx --port=80 --target-port=8000

# Create a service for a replication controller identified by type and name specified in "nginx-controller.yaml", which serves on port 80 and connects to the containers on port 8000.
$ kubectl expose -f nginx-controller.yaml --port=80 --target-port=8000

# Create a service for a pod valid-pod, which serves on port 444 with the name "frontend"
$ kubectl expose pod valid-pod --port=444 --name=frontend

# Create a second service based on the above service, exposing the container port 8443 as port 443 with the name "nginx-https"
$ kubectl expose service nginx --port=443 --target-port=8443 --name=nginx-https

# Create a service for a replicated streaming application on port 4100 balancing UDP traffic and named 'video-stream'.
$ kubectl expose rc streamer --port=4100 --protocol=udp --name=video-stream

# Create a service for a replicated nginx using replica set, which serves on port 80 and connects to the containers on port 8000.
$ kubectl expose rs nginx --port=80 --target-port=8000

# Create a service for an nginx deployment, which serves on port 80 and connects to the containers on port 8000.
$ kubectl expose deployment nginx --port=80 --target-port=8000
</xtermrtf>

<xtermrtf>
$ kubectl expose deployment my-nginx --port=80 --type=LoadBalancer
</xtermrtf>

==== kubectl get ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_get/|Affiche une ressource]] :
<xtermrtf>
# List all pods in ps output format.
$ kubectl get pods

# List all pods in ps output format with more information (such as node name).
$ kubectl get pods -o yaml

# List a single replication controller with specified NAME in ps output format.
$ kubectl get replicationcontroller web

# List a single pod in JSON output format.
$ kubectl get -o json pod web-pod-13je7

# List a pod identified by type and name specified in "pod.yaml" in JSON output format.
$ kubectl get -f pod.yaml -o json

# Return only the phase value of the specified pod.
$ kubectl get -o template pod/web-pod-13je7 --template=

# List all replication controllers and services together in ps output format.
$ kubectl get rc,services

# List one or more resources by their type and names.
$ kubectl get rc/web service/frontend pods/web-pod-13je7
</xtermrtf>

==== kubectl label ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_label/|Gestion des labels sur les ressources]] :
<xtermrtf>
# Update pod 'foo' with the label 'unhealthy' and the value 'true'.
$ kubectl label pods foo unhealthy=true

# Update pod 'foo' with the label 'status' and the value 'unhealthy', overwriting any existing value.
$ kubectl label --overwrite pods foo status=unhealthy

# Update all pods in the namespace
$ kubectl label pods --all status=unhealthy

# Update a pod identified by the type and name in "pod.json"
$ kubectl label -f pod.json status=unhealthy

# Update pod 'foo' only if the resource is unchanged from version 1.
$ kubectl label pods foo status=unhealthy --resource-version=1

# Update pod 'foo' by removing a label named 'bar' if it exists.
# Does not require the --overwrite flag.
$ kubectl label pods foo bar-
</xtermrtf>

==== kubectl logs ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_logs/|Affiche les logs d'un conteneur dans un pod]] :
<xtermrtf>
# Return snapshot logs from pod nginx with only one container
$ kubectl logs nginx

# Return snapshot of previous terminated ruby container logs from pod web-1
$ kubectl logs -p -c ruby web-1

# Begin streaming the logs of the ruby container in pod web-1
$ kubectl logs -f -c ruby web-1

# Display only the most recent 20 lines of output in pod nginx
$ kubectl logs --tail=20 nginx

# Show all logs from pod nginx written in the last hour
$ kubectl logs --since=1h nginx
</xtermrtf>

==== kubectl patch ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_patch/|Met un jour le champ d'une ressource]] :
<xtermrtf>
# Partially update a node using strategic merge patch
$ kubectl patch node k8s-node-1 -p '{"spec":{"unschedulable":true}}'

# Partially update a node identified by the type and name specified in "node.json" using strategic merge patch
$ kubectl patch -f node.json -p '{"spec":{"unschedulable":true}}'

# Update a container's image; spec.containers[*].name is required because it's a merge key
$ kubectl patch pod valid-pod -p '{"spec":{"containers":[{"name":"kubernetes-serve-hostname","image":"new image"}]}}'

# Update a container's image using a json patch with positional arrays
$ kubectl patch pod valid-pod --type='json' -p='[{"op": "replace", "path": "/spec/containers/0/image", "value":"new image"}]
</xtermrtf>

==== kubectl port-forward ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_port-forward/|Forward un port local vers un POD]] :
<xtermrtf>
# Listen on ports 5000 and 6000 locally, forwarding data to/from ports 5000 and 6000 in the pod
$ kubectl port-forward mypod 5000 6000

# Listen on port 8888 locally, forwarding to 5000 in the pod
$ kubectl port-forward mypod 8888:5000

# Listen on a random port locally, forwarding to 5000 in the pod
$ kubectl port-forward mypod :5000

# Listen on a random port locally, forwarding to 5000 in the pod
$ kubectl port-forward  mypod 0:5000
</xtermrtf>

==== kubectl proxy ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_proxy/|Met un proxy pour l'API kubernetes]] :
<xtermrtf>
# Listen on ports 5000 and 6000 locally, forwarding data to/from ports 5000 and 6000 in the pod
$ kubectl port-forward mypod 5000 6000

# Listen on port 8888 locally, forwarding to 5000 in the pod
$ kubectl port-forward mypod 8888:5000

# Listen on a random port locally, forwarding to 5000 in the pod
$ kubectl port-forward mypod :5000

# Listen on a random port locally, forwarding to 5000 in the pod
$ kubectl port-forward  mypod 0:5000
</xtermrtf>

==== kubectl replace ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_replace/|Remplace une ressource par une autre]] :
<xtermrtf>
# Replace a pod using the data in pod.json.
$ kubectl replace -f ./pod.json

# Replace a pod based on the JSON passed into stdin.
$ cat pod.json | kubectl replace -f -

# Update a single-container pod's image version (tag) to v4
$ kubectl get pod mypod -o yaml | sed 's/\(image: myimage\):.*$/\1:v4/' | kubectl replace -f -

# Force replace, delete and then re-create the resource
$ kubectl replace --force -f ./pod.json
</xtermrtf>

==== kubectl rolling-update ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_rolling-update/|Remplace un replication controller par un autre]] :
<xtermrtf>
# Update pods of frontend-v1 using new replication controller data in frontend-v2.json.
$ kubectl rolling-update frontend-v1 -f frontend-v2.json

# Update pods of frontend-v1 using JSON data passed into stdin.
$ cat frontend-v2.json | kubectl rolling-update frontend-v1 -f -

# Update the pods of frontend-v1 to frontend-v2 by just changing the image, and switching the
# name of the replication controller.
$ kubectl rolling-update frontend-v1 frontend-v2 --image=image:v2

# Update the pods of frontend by just changing the image, and keeping the old name.
$ kubectl rolling-update frontend --image=image:v2

# Abort and reverse an existing rollout in progress (from frontend-v1 to frontend-v2).
$ kubectl rolling-update frontend-v1 frontend-v2 --rollback
</xtermrtf>

==== kubectl rollout ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_rollout/|Gére la pause, reprise ou retour arrière d'un déploiement]].

=== kubectl rollout history ===
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_rollout_history/|Affiche l'historique des déploiements]] :
<xtermrtf>
# View the rollout history of a deployment
$ kubectl rollout history deployment/abc

# View the details of deployment revision 3
$ kubectl rollout history deployment/abc --revision=3
</xtermrtf>

=== kubectl rollout pause ===
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_rollout_pause/|Met le déploiement d'une ressource en pause]] :
<xtermrtf>
# Mark the nginx deployment as paused. Any current state of
# the deployment will continue its function, new updates to the deployment will not
# have an effect as long as the deployment is paused.
$ kubectl rollout pause deployment/nginx
</xtermrtf>

=== kubectl rollout resume ===
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_rollout_resume/|Continue le déploiement d'une ressource qui était en pause]] :
<xtermrtf>
# Resume an already paused deployment
$ kubectl rollout resume deployment/nginx
</xtermrtf>

=== kubectl rollout undo ===
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_rollout_undo/|Effectue un retour arrière sur un déploiement précédent]] :
<xtermrtf>
# Rollback to the previous deployment
$ kubectl rollout undo deployment/abc

# Rollback to deployment revision 3
$ kubectl rollout undo deployment/abc --to-revision=3
</xtermrtf>

==== kubectl run ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_run/|Démarre un conteneur à partir d'une image]] :
<xtermrtf>
# Start a single instance of nginx.
kubectl run nginx --image=nginx

# Start a single instance of hazelcast and let the container expose port 5701 .
kubectl run hazelcast --image=hazelcast --port=5701

# Start a single instance of hazelcast and set environment variables "DNS_DOMAIN=cluster" and "POD_NAMESPACE=default" in the container.
kubectl run hazelcast --image=hazelcast --env="DNS_DOMAIN=cluster" --env="POD_NAMESPACE=default"

# Start a replicated instance of nginx.
kubectl run nginx --image=nginx --replicas=5

# Dry run. Print the corresponding API objects without creating them.
kubectl run nginx --image=nginx --dry-run

# Start a single instance of nginx, but overload the spec of the deployment with a partial set of values parsed from JSON.
kubectl run nginx --image=nginx --overrides='{ "apiVersion": "v1", "spec": { ... } }'

# Start a pod of busybox and keep it in the foreground, don't restart it if it exits.
kubectl run -i -t busybox --image=busybox --restart=Never

# Start the nginx container using the default command, but use custom arguments (arg1 .. argN) for that command.
kubectl run nginx --image=nginx -- <arg1> <arg2> ... <argN>

# Start the nginx container using a different command and custom arguments.
kubectl run nginx --image=nginx --command -- <cmd> <arg1> ... <argN>

# Start the perl container to compute π to 2000 places and print it out.
kubectl run pi --image=perl --restart=OnFailure -- perl -Mbignum=bpi -wle 'print bpi(2000)'

# Start the scheduled job to compute π to 2000 places and print it out every 5 minutes.
kubectl run pi --schedule="0/5 * * * ?" --image=perl --restart=OnFailure -- perl -Mbignum=bpi -wle 'print bpi(2000)'
</xtermrtf>

==== kubectl scale ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_scale/|Augmente ou réduite le nombre de conteneur pour un Deployment, ReplicaSet, Replication Controller, ou un Job]] :
<xtermrtf>
# Scale a replicaset named 'foo' to 3.
kubectl scale --replicas=3 rs/foo

# Scale a resource identified by type and name specified in "foo.yaml" to 3.
kubectl scale --replicas=3 -f foo.yaml

# If the deployment named mysql's current size is 2, scale mysql to 3.
kubectl scale --current-replicas=2 --replicas=3 deployment/mysql

# Scale multiple replication controllers.
kubectl scale --replicas=5 rc/foo rc/bar rc/baz

# Scale job named 'cron' to 3.
kubectl scale --replicas=3 job/cron
</xtermrtf>

==== kubectl uncordon ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_uncordon/|Rend le nœud à nouveau éligible pour la création de PODs]] (voir [[#kubectl cordon]]):
<xtermrtf>
# Mark node "foo" as schedulable.
$ kubectl uncordon foo
</xtermrtf>

==== kubectl version ====
[[http://kubernetes.io/docs/user-guide/kubectl/kubectl_version/|Affiche la version client/serveur]] :
<xtermrtf>
$ kubectl version
</xtermrtf>