Configurer un service Cloud Run pour accéder à la fois à un service Cloud Run interne et à l'Internet public

1. Introduction

Présentation

Pour sécuriser le trafic réseau de leurs services et applications, de nombreuses organisations utilisent un réseau cloud privé virtuel (VPC) sur Google Cloud doté de contrôles de périmètre pour empêcher l'exfiltration de données. Un réseau VPC est une version virtuelle d'un réseau physique implémenté dans le réseau de production de Google. Un réseau VPC fournit une connectivité à vos instances de machines virtuelles (VM) Compute Engine, propose des équilibreurs de charge réseau à transfert interne natif et des systèmes proxy pour les équilibreurs de charge d'application internes, se connecte aux réseaux sur site à l'aide de tunnels Cloud VPN et de rattachements de VLAN pour Cloud Interconnect, et répartit le trafic provenant d'équilibreurs de charge Google Cloud externes sur les backends.

Contrairement aux VM, les services Cloud Run ne sont associés à aucun réseau VPC particulier par défaut. Cet atelier de programmation montre comment modifier les paramètres d'entrée (connexions entrantes) afin que seul le trafic provenant d'un VPC puisse accéder à un service Cloud Run (par exemple, un service de backend). De plus, cet atelier de programmation vous explique comment faire en sorte qu'un deuxième service (par exemple, un service de frontend) accède à la fois au service Cloud Run de backend via un VPC et continue d'avoir un accès à l'Internet public.

Dans cet exemple, le service Cloud Run de backend renvoie "hello world". Le service Cloud Run de frontend fournit un champ de saisie dans l'interface utilisateur pour collecter une URL. Le service de frontend envoie ensuite une requête GET à cette URL (par exemple, le service de backend), ce qui en fait une requête de service à service (au lieu d'une requête de navigateur à service). Lorsque le service de frontend peut atteindre le backend, le message "hello world" s'affiche dans le navigateur. Vous verrez ensuite comment appeler https://curlmyip.org pour récupérer l'adresse IP de votre service de frontend.

Points abordés

• Autoriser uniquement le trafic provenant d'un VPC vers votre service Cloud Run
• Configurer la sortie sur un service Cloud Run (par exemple, un frontend) pour communiquer avec un service Cloud Run à entrée uniquement interne (par exemple, un backend), tout en conservant l'accès à l'Internet public pour le service de frontend.

2. Préparation

Prérequis

• Vous êtes connecté à la console Cloud.
• Vous avez déjà déployé une fonction de 2e génération. Par exemple, vous pouvez suivre le guide de démarrage rapide Déployer une fonction Cloud de 2e génération pour commencer.

Activer Cloud Shell

1. Dans Cloud Console, cliquez sur Activer Cloud Shell .

Si vous démarrez Cloud Shell pour la première fois, un écran intermédiaire s'affiche pour vous expliquer de quoi il s'agit. Si cet écran s'affiche, cliquez sur Continuer.

Le provisionnement et la connexion à Cloud Shell ne devraient pas prendre plus de quelques minutes.

Cette machine virtuelle est chargée avec tous les outils de développement nécessaires. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore nettement les performances du réseau et l'authentification. Vous pouvez réaliser une grande partie, voire la totalité, des activités de cet atelier de programmation dans un navigateur.

Une fois connecté à Cloud Shell, vous êtes en principe authentifié, et le projet est défini avec votre ID de projet.

2. Exécutez la commande suivante dans Cloud Shell pour vérifier que vous êtes authentifié :

gcloud auth list

Résultat de la commande

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Remarque : gcloud est l'outil de ligne de commande performant et unifié de Google Cloud. Il est préinstallé dans Cloud Shell. Il est également compatible avec la saisie semi-automatique via la touche de tabulation. Vous serez peut-être invité à vous authentifier la première fois que vous exécuterez une commande. Pour en savoir plus, consultez la présentation de l'outil de ligne de commande gcloud.

3. Exécutez la commande suivante dans Cloud Shell pour vérifier que la commande gcloud reconnaît votre projet :

gcloud config list project

Résultat de la commande

[core]
project = <PROJECT_ID>

Si vous obtenez un résultat différent, exécutez cette commande :

gcloud config set project <PROJECT_ID>

Résultat de la commande

Updated property [core/project].

Remarque : Si vous suivez ce tutoriel en dehors de Cloud Shell, consultez Configurer les identifiants par défaut de l'application.

3. Créer les services Cloud Run

Configurer 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, e.g. us-central1>
FRONTEND=frontend-with-internet
BACKEND=backend
SUBNET_NAME=default

Créer le service Cloud Run de backend

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

mkdir -p egress-private-codelab/frontend-w-internet egress-private-codelab/backend && cd egress-private-codelab/backend

Créez ensuite un fichier `package.json`` contenant les éléments suivants :

{
    "name": "backend-service",
    "version": "1.0.0",
    "description": "",
    "scripts": {
        "start": "node index.js"
    },
    "dependencies": {
        "express": "^4.18.1"
    }
}

Créez ensuite un fichier source index.js avec le contenu ci-dessous. Ce fichier contient le point d'entrée du service et la logique principale de l'application.

const express = require('express');

const app = express();

app.use(express.urlencoded({ extended: true }));

app.get('/', function (req, res) {
    res.send("hello world");
});

const port = parseInt(process.env.PORT) || 8080;
app.listen(port, () => {
    console.log(`helloworld: listening on port ${port}`);
});

Enfin, déployez le service Cloud Run en exécutant la commande suivante.

gcloud run deploy $BACKEND --source . --allow-unauthenticated --region $REGION

Créer le service Cloud Run de frontend

Accédez au répertoire de frontend.

cd ../frontend-w-internet

Créez ensuite un fichier package.json contenant les éléments suivants :

{
  "name": "frontend",
  "version": "1.0.0",
  "description": "",
  "scripts": {
    "start": "node index.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "axios": "^1.6.6",
    "express": "^4.18.2",
    "htmx.org": "^1.9.10"
  }
}

Créez ensuite un fichier source index.js avec le contenu ci-dessous. Ce fichier contient le point d'entrée du service et la logique principale de l'application.

const express = require("express");
const app = express();
const port = 8080;
const path = require('path');
const axios = require('axios');

// serve static content (index.html) using
// built-in middleware function in Express 
app.use(express.static('public'));
app.use(express.urlencoded({ extended: true }));

// this endpoint receives a URL in the post body
// and then makes a get request to that URL
// results are sent back to the caller
app.post('/callService', async (req, res) => {

    const url = req.body.url;
    let message = "";

    try {
        console.log("url: ", url);
        const response = await axios.get(url);
        message = response.data;

    } catch (error) {
        message = error.message;
        console.error(error.message);
    }

    res.send(`
        ${message}
        <p>
        </p>
    `);
});

app.listen(port, () => {
    console.log(`Example app listening on port ${port}`);
});

Créez un répertoire public pour le fichier index.html.

mkdir public
touch public/index.html

Mettez à jour le fichier index.html pour qu'il contienne les éléments suivants :

<html>
  <script
    src="https://unpkg.com/htmx.org@1.9.10"
    integrity="sha384-D1Kt99CQMDuVetoL1lrYwg5t+9QdHe7NLX/SoJYkXDFfX37iInKRy5xLSi8nO7UC"
    crossorigin="anonymous"
  ></script>
  <body>
    <div style="margin-top: 100px; margin-left: 100px">
      <h1>I'm the Request Tester service on the Internet</h1>
      <form hx-trigger="submit" hx-post="/callService" hx-target="#zen">
        <label for="url"> URL:</label>
        <input
          style="width: 308px"
          type="text"
          id="url"
          name="url"
          placeholder="The backend service URL"
          required
        />
        <button hx-indicator="#loading" type="submit">Submit</button>
        <p></p>
        <span class="htmx-indicator" id="loading"> Loading... </span>
        <div id="zen" style="white-space: pre-wrap"></div>
        <p></p>
      </form>
    </div>
  </body>
</html>

Enfin, déployez le service Cloud Run en exécutant la commande suivante.

gcloud run deploy $FRONTEND --source . --allow-unauthenticated --region $REGION

Appeler le service de backend

Dans cette section, vous allez vérifier que vous avez bien déployé deux services Cloud Run.

Ouvrez l'URL du service de frontend dans votre navigateur Web, par exemple https://frontend-your-hash-uc.a.run.app/.

Dans la zone de texte, saisissez l'URL du service de backend. Notez que cette requête est acheminée de l'instance Cloud Run de frontend vers le service Cloud Run de backend, et non depuis votre navigateur.

Le message "hello world" s'affiche.

4. Définir le service de backend pour l'entrée interne uniquement

Vous pouvez exécuter la commande gcloud suivante pour intégrer un service Cloud Run à votre réseau privé.

gcloud run services update $BACKEND --ingress internal --region $REGION

Si vous essayez d'appeler le service de backend à partir du service de frontend, vous recevrez une erreur 404. La connexion sortante (ou sortie) du service Cloud Run de frontend passe d'abord par Internet. Google Cloud ne connaît donc pas l'origine de la requête.

5. Configurer le service de frontend pour accéder au VPC

Dans cette section, vous allez configurer votre service Cloud Run de frontend pour qu'il communique avec votre service de backend via un VPC.

Pour ce faire, vous devez ajouter une sortie VPC directe à votre service Cloud Run de frontend afin de vous assurer qu'il peut atteindre les adresses IP internes du réseau VPC. Ensuite, vous configurerez la sortie de sorte que seules les requêtes ciblant des adresses IP privées soient acheminées vers le VPC. Cette configuration permettra à votre frontend d'accéder à l'Internet public. Pour en savoir plus, consultez la documentation sur la réception de requêtes provenant d'autres services Cloud Run.

Configurer la sortie VPC directe

Commencez par exécuter cette commande pour utiliser la sortie VPC directe sur votre service de frontend :

gcloud beta run services update $FRONTEND \
--network=$SUBNET_NAME \
--subnet=$SUBNET_NAME  \
--vpc-egress=private-ranges-only \
--region=$REGION

Vous pouvez maintenant vérifier que votre service de frontend a accès au VPC :

gcloud beta run services describe $FRONTEND \
--region=$REGION

Un résultat semblable à celui-ci devrait s'afficher :

VPC access:
    Network:        default
    Subnet:          default
    Egress:          private-ranges-only

Activer l'accès privé à Google

Ensuite, vous allez activer l'accès privé à Google sur le sous-réseau en exécutant la commande suivante :

gcloud compute networks subnets update $SUBNET_NAME \
--region=$REGION \
--enable-private-ip-google-access

Vous pouvez vérifier que l'accès privé à Google a été activé en exécutant la commande suivante :

gcloud compute networks subnets describe $SUBNET_NAME \
--region=$REGION \
--format="get(privateIpGoogleAccess)"

Créer une zone Cloud DNS pour les URL run.app

Enfin, créez une zone Cloud DNS pour les URL run.app afin que Google Cloud puisse les traiter comme des adresses IP internes.

Lors d'une étape précédente, vous avez configuré la sortie VPC directe pour les plages privées uniquement. Cela signifie que les connexions sortantes de votre service de frontend ne seront dirigées vers le réseau VPC que si la destination est une adresse IP interne. Toutefois, votre service de backend utilise une URL run.app qui est résolue en une adresse IP publique.

Dans cette étape, vous allez créer une zone Cloud DNS pour que les URL run.app soient résolues en plages d'adresses IP private.googleapis.com, qui sont reconnues comme des adresses IP internes. Désormais, toutes les requêtes adressées à ces plages seront acheminées via votre réseau VPC.

Pour ce faire, consultez https://cloud.google.com/run/docs/securing/private-networking#from-other-services.

# do not include the https:// in your DNS Name
# for example: backend-<hash>-uc.a.run.app
DNS_NAME=<your backend service URL without the https://>

gcloud dns --project=$PROJECT_ID managed-zones create codelab-backend-service \
 --description="" \
 --dns-name="a.run.app." \
 --visibility="private" \
 --networks=$SUBNET_NAME

gcloud dns --project=$PROJECT_ID record-sets create $DNS_NAME. \
--zone="codelab-backend-service" \
 --type="A" \
 --ttl="60" \
--rrdatas="199.36.153.8,199.36.153.9,199.36.153.10,199.36.153.11"

Lorsque vous essayez d'accéder au service de backend de votre site Web, le message "hello world" s'affiche.

Lorsque vous essayez d'accéder à Internet à l'aide de https://curlmyip.org/, votre adresse IP s'affiche.

6. Dépannage

Voici quelques messages d'erreur possibles que vous pouvez rencontrer si les paramètres n'ont pas été configurés correctement.

• Si vous obtenez une erreur getaddrinfo ENOTFOUND backend-your-hash-uc.a.run.app, assurez-vous de ne pas avoir ajouté "https://" à l'enregistrement A DNS.
• Si vous recevez une erreur 404 lorsque vous essayez d'accéder au backend après avoir configuré la zone, vous pouvez attendre l'expiration du cache de l'enregistrement run.app global (par exemple, six heures) ou créer une révision (ce qui efface le cache) en exécutant la commande suivante : gcloud beta run services update $FRONTEND --network=$SUBNET_NAME --subnet=$SUBNET_NAME --vpc-egress=private-ranges-only --region=$REGION

7. Félicitations !

Bravo ! Vous avez terminé cet atelier de programmation.

Nous vous recommandons de consulter la documentation sur la mise en réseau privée sur Cloud Run.

Points abordés

• Autoriser uniquement le trafic provenant d'un VPC vers votre service Cloud Run
• Configurer la sortie sur un service Cloud Run (par exemple, un frontend) pour communiquer avec un service Cloud Run à entrée uniquement interne (par exemple, un backend), tout en conservant l'accès à l'Internet public pour le service de frontend.

8. Effectuer un nettoyage

Pour éviter des frais involontaires (par exemple, si ce service Cloud Run est appelé par inadvertance plus de fois que votre allocation mensuelle 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 les services Cloud Run, accédez à la console Cloud Run à l'adresse https://console.cloud.google.com/functions/, puis supprimez les services $FRONTEND et $BACKEND que vous avez créés 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.