Cette page a été traduite par l'API Cloud Translation.

Utiliser des révisions dans Cloud Run pour la répartition du trafic, les déploiements progressifs et les rollbacks

1. Introduction

Présentation

Les révisions Cloud Run vous permettent d'indiquer les révisions qui doivent recevoir du trafic et le pourcentage de trafic à envoyer à chaque révision. Les révisions vous permettent d'effectuer un rollback vers une révision précédente, de déployer progressivement une révision et de répartir le trafic entre plusieurs révisions.

Ces ateliers de programmation vous expliquent comment utiliser les révisions pour gérer le trafic vers votre service Cloud Run. Pour en savoir plus sur les révisions, consultez la documentation Cloud Run.

Points abordés

Répartir le trafic entre deux révisions ou plus pour un service Cloud Run
Déployer progressivement une nouvelle révision
Effectuer un rollback vers une révision précédente

2. Préparation

Prérequis

Vous êtes connecté à Cloud Console.
Vous avez déjà déployé un service Cloud Run. Par exemple, vous pouvez suivre la procédure de déploiement d'un service Cloud Run pour commencer.

Définir des variables d'environnement

Vous pouvez définir des variables d'environnement qui seront utilisées tout au long de cet atelier de programmation.

PROJECT_ID=YOUR-PROJECT-ID
REGION=YOUR_REGION

BG_COLOR=darkseagreen
SERVICE_NAME=traffic-revisions-color
AR_REPO=traffic-revisions-color-repo

Créer un dépôt Artifact Registry pour le service

gcloud artifacts repositories create $AR_REPO \
    --repository-format=docker \
    --location=$REGION \
    --description="codelab for finetuning using CR jobs" \
    --project=$PROJECT_ID

3. Répartition du trafic

Cet exemple vous montre comment créer un service Cloud Run qui lit une variable d'environnement de couleur et renvoie le nom de la révision à l'aide de cette couleur d'arrière-plan.

Bien que cet atelier de programmation utilise Python, vous pouvez utiliser n'importe quel environnement d'exécution.

Définir des variables d'environnement

Vous pouvez définir des variables d'environnement qui seront utilisées tout au long de cet atelier de programmation.

REGION=<YOUR_REGION>
PROJECT_ID=<YOUR-PROJECT-ID>
BG_COLOR=darkseagreen
SERVICE_NAME=traffic-revisions-color
AR_REPO=traffic-revisions-color-repo

Créer le service

Commencez par créer un répertoire pour le code source et accédez-y avec la commande cd.

mkdir traffic-revisions-codelab && cd $_

Créez ensuite un fichier main.py avec le contenu suivant:

import os
from flask import Flask, render_template_string

app = Flask(__name__)

TEMPLATE = """
<!doctype html>
<html lang="en">
<head>
    <title>Cloud Run Traffic Revisions</title>
    <style>
        body {
            display: flex;
            justify-content: center;
            align-items: center;
            min-height: 50vh;
            background-color: {{ bg_color }}; /* Set by environment variable */
            font-family: sans-serif;
        }
        .content {
            background-color: rgba(255, 255, 255, 0.8); /* Semi-transparent white background */
            padding: 2em;
            border-radius: 8px;
            text-align: center;
            box-shadow: 0 4px 8px rgba(0,0,0,0.1);
        }
    </style>
</head>
<body>
    <div class="content">
        <p>background color: <strong>{{ color_name }}</strong></p>
    </div>
</body>
</html>
"""

@app.route('/')
def main():
    """Serves the main page with a background color from the ENV."""
    # Get the color from the 'BG_COLOR' environment variable.
    # Default to 'white' if the variable is not set.
    color = os.environ.get('BG_COLOR', 'white').lower()

    return render_template_string(TEMPLATE, bg_color=color, color_name=color)

if __name__ == '__main__':
    port = int(os.environ.get('PORT', 8080))
    app.run(debug=True, host='0.0.0.0', port=port)

Ensuite, créez un fichier requirements.txt avec le contenu suivant:

Flask>=2.0.0
gunicorn>=20.0.0

Enfin, créez un Dockerfile.

FROM python:3.12-slim

WORKDIR /app

COPY requirements.txt .

RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8080

ENV PYTHONPATH /app

CMD ["gunicorn", "--bind", "0.0.0.0:8080", "main:app"]

Créez l'image dans Artifact Registry à l'aide de Buildpacks avec Cloud Build:

gcloud builds submit \
   --tag $REGION-docker.pkg.dev/$PROJECT_ID/$AR_REPO/$SERVICE_NAME

Déployez la première révision dans Cloud Run avec une couleur darkseagreen:

gcloud run deploy $SERVICE_NAME \
    --image $REGION-docker.pkg.dev/$PROJECT_ID/$AR_REPO/$SERVICE_NAME:latest \
    --region $REGION \
    --allow-unauthenticated \
    --set-env-vars BG_COLOR=darkseagreen

Pour tester le service, vous pouvez ouvrir le point de terminaison directement dans votre navigateur Web pour voir la couleur d'arrière-plan en vert foncé.

Déployez maintenant une deuxième révision avec une couleur d'arrière-plan beige.

# update the env var
BG_COLOR=tan

gcloud run deploy $SERVICE_NAME \
    --image $REGION-docker.pkg.dev/$PROJECT_ID/$AR_REPO/$SERVICE_NAME:latest \
    --region $REGION \
    --set-env-vars BG_COLOR=tan

Lorsque vous actualisez le site Web, la couleur d'arrière-plan beige s'affiche.

Répartir le trafic en 50/50

Pour répartir le trafic entre les révisions vert foncé et beige, vous devez trouver les ID de révision des services Cloud Run sous-jacents. Vous pouvez afficher les ID de révision en exécutant la commande suivante:

gcloud run revisions list --service $SERVICE_NAME \
  --region $REGION --format 'value(REVISION)'

Un résultat semblable aux lignes suivantes doit s'afficher :

traffic-revisions-color-00003-qoq
traffic-revisions-color-00002-zag

Vous pouvez répartir le trafic 50/50 entre les deux révisions en exécutant la commande suivante avec vos révisions:

gcloud run services update-traffic $SERVICE_NAME \
  --region $REGION \
  --to-revisions YOUR_REVISION_1=50,YOUR_REVISION_2=50

Tester la répartition du trafic

Vous pouvez tester le service en actualisant la page dans votre navigateur.

La moitié du temps, vous devriez voir la révision vert foncé et l'autre moitié, la révision beige. Le nom de la révision s'affiche également dans la sortie, par exemple :

<html><body style="background-color:tan;"><div><p>Hello traffic-revisions-color-00003-qoq</p></div></body></html>

4. Déploiements progressifs

Dans cette section, vous allez découvrir comment déployer progressivement les modifications apportées à une nouvelle version d'un service Cloud. Pour en savoir plus sur le déploiement progressif, consultez la documentation.

Vous allez utiliser le même code que dans la section précédente, mais vous allez le déployer en tant que nouveau service Cloud Run.

Tout d'abord, définissez la couleur d'arrière-plan sur beige et déployez la fonction avec le nom gradual-rollouts-colors.

Pour déployer une fonction Cloud Run directement sur Cloud Run, exécutez la commande suivante:

# update the env var
BG_COLOR=beige

gcloud beta run deploy gradual-rollouts-colors \
      --image $REGION-docker.pkg.dev/$PROJECT_ID/$AR_REPO/$SERVICE_NAME:latest \
      --region $REGION \
      --allow-unauthenticated \
      --update-env-vars BG_COLOR=$BG_COLOR

Supposons maintenant que nous souhaitions déployer progressivement une nouvelle version avec une couleur d'arrière-plan lavande.

Commençons par définir la révision actuelle beige pour qu'elle reçoive 100% du trafic. Cela garantit que vos futures révisions ne recevront aucun trafic. Par défaut, Cloud Run définit le trafic à 100% sur la révision avec l'indicateur latest. En spécifiant manuellement que cette révision beige actuelle doit recevoir tout le trafic, la révision avec l'indicateur latest ne recevra plus 100% du trafic. Consultez la documentation.

# get the revision name

BEIGE_REVISION=$(gcloud run revisions list --service gradual-rollouts-colors \
  --region $REGION --format 'value(REVISION)')

# now set 100% traffic to that revision

gcloud run services update-traffic gradual-rollouts-colors \
  --to-revisions=$BEIGE_REVISION=100 \
  --region $REGION

Un résultat semblable à Traffic: 100% radual-rollouts-colors-00001-yox s'affiche.

Vous pouvez maintenant déployer une nouvelle révision qui ne recevra aucun trafic. Au lieu de modifier le code, vous pouvez mettre à jour la variable d'environnement BG_COLOR pour cette révision.

Pour déployer une fonction Cloud Run directement sur Cloud Run, exécutez la commande suivante:

# update color

BG_COLOR=lavender

# deploy the function that will not receive any traffic
gcloud beta run deploy gradual-rollouts-colors \
      --image $REGION-docker.pkg.dev/$PROJECT_ID/$AR_REPO/$SERVICE_NAME:latest \
      --region $REGION \
      --allow-unauthenticated \
      --update-env-vars BG_COLOR=$BG_COLOR

Lorsque vous accédez au site Web dans votre navigateur, la couleur beige s'affiche, même si la version la plus récente est la lavande.

Tester une révision qui ne diffuse aucun trafic

Supposons que vous ayez vérifié que votre révision a bien été déployée et qu'elle ne diffuse aucun trafic. Même si les vérifications de l'état ont réussi, vous devez vérifier que cette révision utilise la couleur de fond lavande.

Pour tester la révision lavande, vous pouvez lui appliquer un tag. Le taggage vous permet de tester directement la nouvelle révision sur une URL spécifique, sans diffuser de trafic.

Commencez par obtenir l'URL de l'image de cette dernière révision (lavande).

IMAGE_URL_LAVENDER=$(gcloud run services describe gradual-rollouts-colors --region $REGION --format 'value(IMAGE)')

Taguez maintenant cette image avec la couleur qui lui est associée.

gcloud run deploy gradual-rollouts-colors --image $IMAGE_URL_LAVENDER --no-traffic --tag $BG_COLOR --region $REGION

Vous devez obtenir un résultat semblable à ce qui suit :

The revision can be reached directly at https://lavender---gradual-rollouts-colors-<hash>-<region>.a.run.app

Lorsque vous accéderez à l'URL de cette révision spécifique, la couleur lavande s'affichera.

Augmenter progressivement le trafic

Vous pouvez maintenant commencer à envoyer du trafic vers la version lavande. L'exemple ci-dessous montre comment envoyer 1% du trafic vers lavande.

gcloud run services update-traffic gradual-rollouts-colors --region $REGION --to-tags lavender=1

Pour envoyer 50% du trafic vers lavande, vous pouvez utiliser la même commande, mais spécifier 50% à la place.

gcloud run services update-traffic gradual-rollouts-colors --region $REGION --to-tags lavender=50

Vous devriez voir une liste du trafic généré par chaque révision.

Traffic:
  50% gradual-rollouts-colors-00001-hos
  50% gradual-rollouts-colors-00004-mum
        lavender: https://lavender---gradual-rollouts-colors-<hash>-<region>.a.run.app

Lorsque vous êtes prêt à déployer complètement le lilas, vous pouvez le définir à 100% pour remplacer le beige.

gcloud run services update-traffic gradual-rollouts-colors --region $REGION --to-tags lavender=100

Lorsque vous accédez au site Web, vous ne voyez plus que la couleur lavande.

5. Rollbacks

Supposons que les premiers commentaires UX indiquent que les clients préfèrent le beige au lilas, et que vous devez revenir au beige.

Vous pouvez revenir à la version précédente (beige) en exécutant la commande suivante:

gcloud run services update-traffic gradual-rollouts-colors --region $REGION --to-revisions $BEIGE_REVISION=100

Lorsque vous accédez au site Web, la couleur d'arrière-plan est désormais beige.

Pour en savoir plus sur les rollbacks, consultez la documentation.

6. Félicitations !

Félicitations ! Vous avez terminé cet atelier de programmation.

Nous vous recommandons de consulter la documentation sur les déploiements, les rollbacks et la migration du trafic.

Points abordés

Répartir le trafic entre deux révisions ou plus pour un service Cloud Run
Déployer progressivement une nouvelle révision
Effectuer un rollback vers une révision précédente

7. Effectuer un nettoyage

Pour éviter les frais involontaires (par exemple, si cette fonction Cloud Run est appelée par inadvertance plus de fois que votre quota mensuel d'appels Cloud Run dans le niveau sans frais), vous pouvez supprimer le service Cloud Run ou le projet que vous avez créé à l'étape 2.

Pour supprimer un service Cloud Run, accédez à Cloud Run dans la console Cloud Console à l'adresse https://console.cloud.google.com/run/, puis supprimez les fonctions que vous avez créées dans cet atelier de programmation.

Si vous choisissez de supprimer l'ensemble du projet, accédez à https://console.cloud.google.com/cloud-resource-manager, sélectionnez le projet que vous avez créé à l'étape 2, puis choisissez "Supprimer". Si vous supprimez le projet, vous devrez modifier les projets dans votre SDK Cloud. Vous pouvez afficher la liste de tous les projets disponibles en exécutant gcloud projects list.