Kubernetes comment effectuer un déploiement pour mettre à jour l'image

J'ai un déploiement avec un seul pod, avec mon image de menu fixe personnalisée comme:

containers:
  - name: mycontainer
    image: myimage:latest

Pendant le développement, je veux pousser la nouvelle version la plus récente et mettre à jour le déploiement. Impossible de trouver comment faire cela, sans définir explicitement la balise / version et l'incrémenter pour chaque build, et faire

kubectl set image deployment/my-deployment mycontainer=myimage:1.9.1

Vous pouvez configurer votre pod avec une période de grâce (par exemple 30 secondes ou plus, selon l'heure de démarrage du conteneur et la taille de l'image) et définir "imagePullPolicy: "Always". Et utilisez kubectl delete pod pod_name. Un nouveau conteneur sera créé et la dernière image téléchargée automatiquement, puis l'ancien conteneur se terminera.

Exemple:

spec:
  terminationGracePeriodSeconds: 30
  containers:
  - name: my_container
    image: my_image:latest
    imagePullPolicy: "Always"

J'utilise actuellement Jenkins pour les builds automatisés et le marquage d'image et cela ressemble à ceci:

kubectl --user="kube-user" --server="https://kubemaster.example.com"  --token=$ACCESS_TOKEN set image deployment/my-deployment mycontainer=myimage:"$BUILD_NUMBER-$SHORT_GIT_COMMIT"

Une autre astuce consiste à exécuter initialement:

kubectl set image deployment/my-deployment mycontainer=myimage:latest

puis:

kubectl set image deployment/my-deployment mycontainer=myimage

Cela déclenchera en fait la mise à jour continue, mais assurez-vous que vous avez également imagePullPolicy: "Always"défini.

Mettre à jour:

une autre astuce que j'ai trouvée, où vous n'avez pas à changer le nom de l'image, est de changer la valeur d'un champ qui déclenchera une mise à jour progressive, comme terminationGracePeriodSeconds. Vous pouvez le faire en utilisant kubectl edit deployment your_deploymentou kubectl apply -f your_deployment.yamlou en utilisant un patch comme celui-ci:

kubectl patch deployment your_deployment -p \
  '{"spec":{"template":{"spec":{"terminationGracePeriodSeconds":31}}}}'

Assurez-vous simplement de toujours modifier la valeur numérique.

MISE À JOUR 2019-06-24

Sur la base du commentaire @Jodiug, si vous avez une 1.15version, vous pouvez utiliser la commande:

kubectl rollout restart deployment/demo

En savoir plus sur le problème:

https://github.com/kubernetes/kubernetes/issues/13488

Eh bien, il y a une discussion intéressante à ce sujet sur le projet Kubernetes GitHub. Voir le problème: https://github.com/kubernetes/kubernetes/issues/33664

À partir des solutions décrites ici, je suggérerais l'une des deux.

Première

1. préparer le déploiement

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: demo
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: demo
    spec:
      containers:
      - name: demo
        image: registry.example.com/apps/demo:master
        imagePullPolicy: Always
        env:
        - name: FOR_GODS_SAKE_PLEASE_REDEPLOY
          value: 'THIS_STRING_IS_REPLACED_DURING_BUILD'

2. déployer

sed -ie "s/THIS_STRING_IS_REPLACED_DURING_BUILD/$(date)/g" deployment.yml
kubectl apply -f deployment.yml

Deuxième (une doublure):

kubectl patch deployment web -p \
  "{\"spec\":{\"template\":{\"metadata\":{\"labels\":{\"date\":\"`date +'%s'`\"}}}}}"

Bien sûr, le imagePullPolicy: Alwaysest requis dans les deux cas.

kubectl rollout restart deployment myapp

C'est la manière actuelle de déclencher une mise à jour progressive et de laisser les anciens jeux de répliques en place pour d'autres opérations fournies par des kubectl rolloutrestaurations similaires.

J'utilise Gitlab-CI pour créer l'image, puis la déployer directement sur GCK. Si vous utilisez une petite astuce pour réaliser une mise à jour progressive sans changer les paramètres réels du conteneur, ce qui change une étiquette en commit-short-sha actuel.

Ma commande ressemble à ceci:

kubectl patch deployment my-deployment -p "{\"spec\":{\"template\":{\"metadata\":{\"labels\":{\"build\":\"$CI_COMMIT_SHORT_SHA\"}}}}}}"

Où vous pouvez utiliser n'importe quel nom et n'importe quelle valeur pour l'étiquette tant qu'elle change à chaque build.

S'amuser!

Il semble que k8s s'attend à ce que nous fournissions une balise d'image différente pour chaque déploiement. Ma stratégie par défaut serait de faire en sorte que le système CI génère et pousse les images du docker, en les étiquetant avec le numéro de build:xpmatteo/foobar:456 .

Pour le développement local, il peut être pratique d'utiliser un script ou un makefile, comme ceci:

# create a unique tag    
VERSION:=$(shell date +%Y%m%d%H%M%S)
TAG=xpmatteo/foobar:$(VERSION)

deploy:
    npm run-script build
    docker build -t $(TAG) . 
    docker push $(TAG)
    sed s%IMAGE_TAG_PLACEHOLDER%$(TAG)% foobar-deployment.yaml | kubectl apply -f - --record

La sedcommande remplace un espace réservé dans le document de déploiement par la balise d'image réellement générée.

J'utilise Azure DevOps pour déployer les applications de conteneurisation, je parviens facilement à surmonter ce problème en utilisant l'ID de build

Chaque fois que ses builds et génèrent le nouvel ID de build, j'utilise cet ID de build comme balise pour l'image docker, voici un exemple

imageename: buildID

une fois que votre image est construite (CI) avec succès, dans le pipeline de CD dans le fichier yml de déploiement, j'ai donné le nom de l'image comme

imagename: env: buildID

ici evn: buildid est la variable azure devops qui a la valeur de build ID.

donc maintenant, chaque fois que j'ai de nouveaux changements à construire (CI) et à déployer (CD).

veuillez commenter si vous avez besoin d'une définition de construction pour CI / CD.