Tester un service Cloud Run localement

Pendant le développement, vous pouvez exécuter et tester votre image de conteneur localement, avant de la déployer. Vous pouvez utiliser Cloud Code ou Docker installé localement pour exécuter et tester en local, y compris avec un accès aux services Google Cloud.

Docker

Pour tester votre image de conteneur localement à l'aide de Docker, procédez comme suit :

Exécutez la commande Docker :
```
PORT=8080 && docker run -p 9090:${PORT} -e PORT=${PORT} IMAGE_URL
```
Remplacez IMAGE_URL par une référence à l'image de conteneur, par exemple us-docker.pkg.dev/cloudrun/container/hello:latest. Si vous utilisez Artifact Registry, le dépôt REPO_NAME doit déjà être créé. L'URL se présente sous la forme suivante : REGION-docker.pkg.dev/PROJECT_ID/REPO_NAME/PATH:TAG.

La variable d'environnement PORT spécifie le port que votre application utilisera pour écouter les requêtes HTTP ou HTTPS. Il s'agit d'une exigence du contrat d’exécution du conteneur. Dans cet exemple, nous utilisons le port 8080.

Important : Lors de la première exécution en local :
Si vous essayez d'exécuter cette commande pour la première fois en local, vous ne disposez peut-être pas de toutes les autorisations nécessaires pour accéder à l'image à partir du registre d'images que vous utilisez. Si vous utilisez Artifact Registry, suivez les instructions d'authentification d'Artifact Registry. Si vous utilisez Container Registry, suivez les instructions d'authentification de Container Registry. Après avoir configuré votre registre de manière appropriée, essayez d'exécuter à nouveau votre conteneur Cloud Run en local.
Attention : Utilisation du compte de service par défaut :
Si vous utilisez le compte de service par défaut lors du déploiement sur Cloud Run, sachez qu'il n'est pas disponible localement. Vous devez donc disposer d'un compte de service avec une paire de clés privées enregistrée localement afin d'exécuter l'image en local avec Docker. Pour en savoir plus, consultez l'onglet Docker avec accès Google Cloud.
Ouvrez http://localhost:9090 dans votre navigateur.

Si vous débutez avec les conteneurs, consultez le guide de démarrage de Docker. Pour en savoir plus sur les commandes Docker, consultez la documentation de Docker.

Docker avec accès Google Cloud

Si vous utilisez des bibliothèques clientes Google Cloud pour intégrer votre application aux services Google Cloud, et si vous n'avez pas encore sécurisé ces services pour contrôler l'accès externe, vous pouvez configurer votre conteneur local pour vous authentifier auprès des services Google Cloud à l'aide des identifiants par défaut de l'application.

Pour exécuter une image en local, procédez comme suit :

Reportez-vous à la page Premier pas avec l'authentification pour savoir comment générer, récupérer et configurer vos identifiants de compte de service.
Les options d'exécution de Docker suivantes injectent les identifiants et la configuration de votre système local dans le conteneur local :
1. Utilisez l'option --volume (-v) pour injecter le fichier d'identifiants dans le conteneur (en supposant que vous avez déjà défini votre variable d'environnement GOOGLE_APPLICATION_CREDENTIALS sur votre machine) :
```
-v $GOOGLE_APPLICATION_CREDENTIALS:/tmp/keys/FILE_NAME.json:ro
```
2. Utilisez l'option --environment (-e) pour définir la variable GOOGLE_APPLICATION_CREDENTIALS dans le conteneur :
```
-e GOOGLE_APPLICATION_CREDENTIALS=/tmp/keys/FILE_NAME.json
```
Vous pouvez éventuellement utiliser la commande Docker run entièrement configurée ci-après :
```
PORT=8080 && docker run \
-p 9090:${PORT} \
-e PORT=${PORT} \
-e K_SERVICE=dev \
-e K_CONFIGURATION=dev \
-e K_REVISION=dev-00001 \
-e GOOGLE_APPLICATION_CREDENTIALS=/tmp/keys/FILE_NAME.json \
-v $GOOGLE_APPLICATION_CREDENTIALS:/tmp/keys/FILE_NAME.json:ro \
IMAGE_URL
```
Notez que le chemin d'accès
```
/tmp/keys/FILE_NAME.json
```
indiqué dans l'exemple ci-dessus est un emplacement approprié pour placer vos identifiants à l'intérieur du conteneur.

D'autres emplacements de répertoire peuvent également convenir. L'essentiel est que la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS corresponde à l'emplacement du montage lié (bind mount) dans le conteneur.

Notez également qu'avec certains services Google Cloud, vous pouvez utiliser une autre configuration pour isoler le dépannage local des performances et des données de production.

Émulateur Cloud Code

Le plug-in Cloud Code pour les IDE JetBrains et VS Code vous permet d'exécuter et de déboguer votre image de conteneur localement dans un émulateur Cloud Run au sein de votre IDE. Cet émulateur vous permet de configurer un environnement représentatif de votre service exécuté sur Cloud Run.

Vous pouvez configurer des propriétés telles que l'allocation de processeur et de mémoire, spécifier des variables d'environnement et définir les connexions à la base de données Cloud SQL.

Installez Cloud Code pour un IDE JetBrains ou VS Code.
Suivez les instructions permettant de développer et de déboguer en local dans votre IDE.
VS Code : développement et débogage en local
IntelliJ : développement et débogage en local

CLI gcloud

Google Cloud CLI contient un environnement de développement local permettant d'émuler Cloud Run, qui peut créer un conteneur à partir de la source, exécuter le conteneur sur votre machine locale, puis reconstruire automatiquement le conteneur en fonction des modifications du code source.

Pour démarrer l'environnement de développement local :

Remplacez le répertoire par celui qui contient le code source de votre service.
Appelez la commande :
```
gcloud beta code dev
```

Si un Dockerfile est présent dans le répertoire local, il est utilisé pour créer le conteneur. Si aucun fichier Dockerfile n'est présent, le conteneur est créé à l'aide des packs de création Google Cloud.

Pour voir votre service en cours d'exécution, saisissez l'adresse http://localhost:8080/ dans votre navigateur. Si vous avez spécifié un port personnalisé avec l'option --local-port, n'oubliez pas d'ouvrir votre navigateur pour ce port.

Pour arrêter le serveur local :

Mac OS et Linux : Contrôle+C
Windows : Contrôle-Pause

Personnaliser la configuration du service

Vous pouvez personnaliser la configuration Cloud Run du service qui s'exécute localement à l'aide d'un fichier YAML. Le format YAML peut être utilisé pour déployer un service Cloud Run, mais n'est compatible qu'avec un sous-ensemble des paramètres de service Cloud Run. gcloud beta code dev recherche et utilise tous les fichiers se terminant par *.service.dev.yaml dans le répertoire actuel. Si aucun fichier n'est trouvé, le fichier se terminant par *.service.yaml est utilisé.

Vous pouvez configurer les paramètres suivants pour le développement local :

Le champ image du conteneur n'est pas requis pour le développement local, car l'image est créée et fournie au service lors de l'exécution de la commande.

Vous pouvez utiliser l'exemple de fichier service.dev.yaml suivant pour le développement local :

  apiVersion: serving.knative.dev/v1
  kind: Service
  metadata:
    name: my-service-name
  spec:
    template:
      spec:
        containers:
        - env:
          - name: FOO
            value: bar

Tester à l'aide d'identifiants

Pour autoriser le conteneur à utiliser les services Google Cloud, vous devez lui attribuer un identifiant d'accès.

Pour permettre au conteneur d'accéder à un identifiant à l'aide de votre propre compte, connectez-vous à l'aide de gcloud et utilisez l'option --application-default-credential :
```
gcloud auth application-default login
gcloud beta code dev --dockerfile=PATH_TO_DOCKERFILE --application-default-credential
```
Pour attribuer des identifiants à l'application en tant que compte de service, utilisez l'option --service-account :
```
gcloud beta code dev --dockerfile=PATH_TO_DOCKERFILE --service-account=SERVICE_ACCOUNT_EMAIL
```
L'option --service-account entraîne le téléchargement et la mise en cache en local d'une clé de compte de service. L'utilisateur est tenu de sécuriser la clé et de la supprimer lorsqu'elle n'est plus nécessaire.

Vérifier que votre code s'exécute localement

Lors des tests locaux effectués sur Cloud Run, vous pouvez vérifier dans votre code que votre conteneur s'exécute localement en vérifiant la variable d'environnement K_REVISION, que Cloud Run met à la disposition de tous les conteneurs.

Docker

Pour vérifier que vous exécutez votre code localement sur Google Cloud CLI, vous pouvez essayer d'interroger la variable d'environnement K_REVISION. Comme elle n'a pas été définie, elle ne sera associée à aucune valeur.

Docker avec accès Google Cloud

Si vous avez utilisé les valeurs exactes de la section ci-dessus à l'étape 3 pour vérifier que vous exécutez votre code localement sur Google Cloud CLI, vous pouvez interroger la variable d'environnement K_REVISION et rechercher la valeur dev-00001. pour vérifier que votre code s'exécute localement.

Émulateur Cloud Code

Pour vérifier que vous exécutez votre code localement sur Cloud Code, vous pouvez interroger la variable d'environnement K_REVISION et rechercher la valeur local pour confirmer que votre code s'exécute localement.

gcloud CLI

Pour vérifier que vous exécutez votre code localement sur Google Cloud CLI, vous pouvez interroger la variable d'environnement K_REVISION et rechercher une valeur commençant par dev- pour confirmer que votre code s'exécute localement.

Étapes suivantes

Pour savoir comment résoudre un problème d'application Cloud Run localement, consultez le tutoriel Dépannage local d'un service Cloud Run.
Pour savoir comment déployer vos conteneurs une fois qu'ils sont créés, reportez-vous à la page Déployer des services.