Remarque : Go 1.11 n'est plus compatible à partir du 30 janvier 2024. Vos applications Go 1.11 existantes continueront à fonctionner et à recevoir du trafic. Toutefois, App Engine peut bloquer le redéploiement des applications qui utilisent des environnements d'exécution après leur date de fin de compatibilité. Nous vous recommandons de migrer vers la dernière version compatible de Go.

Adresses IP sortantes pour les services App Engine

Les services sortants, tels que les API URL Fetch, Sockets et Mail, utilisent un vaste pool d'adresses IP. Les plages d'adresses IP de ce pool sont sujettes à des modifications de routine. En effet, deux appels d'API séquentiels provenant de la même application peuvent sembler provenir de deux adresses IP différentes.

Si vous devez connaître les adresses IP associées au trafic sortant de votre service, vous pouvez trouver les plages d'adresses IP actuelles de votre service ou configurer une adresse IP statique pour le service.

Adresses IP pour les services App Engine

Vous pouvez trouver les plages d'adresses IP actuelles de vos services App Engine en fonction des informations de plages d'adresses IP publiées par Google :

Google publie la liste complète des plages d'adresses IP mises à la disposition des utilisateurs sur Internet dans le fichier goog.json.
Google publie également une liste de plages d'adresses IP externes globales et régionales disponibles pour les ressources Google Cloud des clients dans le fichier cloud.json.

Les adresses IP utilisées par les API et les services Google correspondent à la liste des plages calculées en supprimant toutes les plages de cloud.json par rapport à celles de goog.json. Ces listes sont mises à jour fréquemment.

Vous pouvez utiliser le script Python suivant pour créer une liste de plages d'adresses IP, incluant celles utilisées par les API et les services Google.

Pour en savoir plus sur l'exécution de ce script, consultez la page Exécuter.

from __future__ import print_function

import json

try:
    from urllib import urlopen
except ImportError:
    from urllib.request import urlopen
    from urllib.error import HTTPError

import netaddr

IPRANGE_URLS = {
    "goog": "https://www.gstatic.com/ipranges/goog.json",
    "cloud": "https://www.gstatic.com/ipranges/cloud.json",
}


def read_url(url):
    try:
        return json.loads(urlopen(url).read())
    except (IOError, HTTPError):
        print("ERROR: Invalid HTTP response from %s" % url)
    except json.decoder.JSONDecodeError:
        print("ERROR: Could not parse HTTP response from %s" % url)


def get_data(link):
    data = read_url(link)
    if data:
        print("{} published: {}".format(link, data.get("creationTime")))
        cidrs = netaddr.IPSet()
        for e in data["prefixes"]:
            if "ipv4Prefix" in e:
                cidrs.add(e.get("ipv4Prefix"))
            if "ipv6Prefix" in e:
                cidrs.add(e.get("ipv6Prefix"))
        return cidrs


def main():
    cidrs = {group: get_data(link) for group, link in IPRANGE_URLS.items()}
    if len(cidrs) != 2:
        raise ValueError("ERROR: Could process data from Google")
    print("IP ranges for Google APIs and services default domains:")
    for ip in (cidrs["goog"] - cidrs["cloud"]).iter_cidrs():
        print(ip)


if __name__ == "__main__":
    main()

Configurer une adresse IP sortante statique

Pour configurer une adresse IP statique pour votre service d'environnement standard App Engine, utilisez l'accès au VPC sans serveur avec Cloud Router et Cloud NAT. Avec l'accès au VPC sans serveur, vous pouvez envoyer le trafic sortant vers votre réseau de cloud privé virtuel (VPC). En utilisant une passerelle de traduction d'adresses réseau (NAT) sur votre VPC, vous pouvez acheminer le trafic App Engine via une adresse IP dédiée.

Le routage de votre trafic via Cloud NAT ne provoque pas de saut supplémentaire dans votre pile réseau, car la passerelle Cloud NAT et le routeur Cloud Router ne fournissent qu'un plan de contrôle, et les paquets ne passent pas par la passerelle NAT ou le routeur Cloud Router.

Les adresses IP sortantes statiques ne peuvent pas être configurées pour le trafic envoyé à l'aide du service de récupération d'URL. Le trafic envoyé à l'aide du service de récupération d'URL continuera à utiliser le pool d'adresses IP publiques. Si vous souhaitez que tout le trafic sortant utilise une adresse IP statique, désactivez la récupération d'URL par défaut en utilisant des sockets et arrêtez toute utilisation explicite de urlfetch.

Les étapes suivantes montrent comment configurer une adresse IP sortante statique pour le service d'environnement standard App Engine.

Assurez-vous de disposer du rôle roles/compute.networkAdmin ou d'un rôle personnalisé avec les mêmes autorisations.
Créez un sous-réseau à l'intérieur de votre réseau VPC pour le trafic App Engine. Cela garantit que les autres ressources de votre réseau VPC ne peuvent pas utiliser l'adresse IP statique.
```
gcloud compute networks subnets create SUBNET_NAME \
    --range=RANGE \
    --network=NETWORK_NAME \
    --region=REGION
```
Dans la commande ci-dessus, remplacez :
- SUBNET_NAME par le nom que vous souhaitez attribuer au sous-réseau ;
- RANGE par la plage d'adresses IP, au format CIDR, que vous souhaitez attribuer à ce sous-réseau (par exemple, 10.124.0.0/28) ;
- NETWORK_NAME par le nom de votre réseau VPC ;
- REGION par la région de votre service App Engine.
Connectez votre service App Engine au sous-réseau.

Suivez le guide Se connecter à un réseau VPC et spécifiez le nom du sous-réseau que vous avez créé à l'étape précédente pour le sous-réseau de connecteur.
Créez un routeur Cloud Router. Cloud Router est un composant de plan de contrôle nécessaire pour Cloud NAT.
```
gcloud compute routers create ROUTER_NAME \
    --network=NETWORK_NAME \
    --region=REGION
```
Dans la commande ci-dessus, remplacez :
- ROUTER_NAME par le nom de la ressource Cloud Router que vous souhaitez créer.
- NETWORK_NAME par le nom de votre réseau VPC ;
- REGION par la région dans laquelle vous souhaitez créer une passerelle NAT.
Réserver une adresse IP statique

Il s'agit de l'adresse que votre service utilisera pour envoyer du trafic sortant. Une ressource d'adresse IP réservée conserve l'adresse IP sous-jacente lorsque la ressource à laquelle elle est associée est supprimée et recréée. Cette adresse IP est comptabilisée dans les quotas d'adresses IP statiques de votre projet Google Cloud.
```
gcloud compute addresses create ORIGIN_IP_NAME \
    --region=REGION
```
Dans la commande ci-dessus, remplacez :
- ORIGIN_IP_NAME par le nom que vous souhaitez attribuer à la ressource d'adresse IP.
- REGION par la région qui exécute le routeur Cloud NAT. Idéalement, la même région que votre service App Engine, afin de minimiser la latence et les coûts du réseau.
Utilisez la commande compute addresses describe pour afficher le résultat :
```
gcloud compute addresses describe ORIGIN_IP_NAME
```
Créez une passerelle Cloud NAT et spécifiez votre adresse IP.

Le trafic provenant de votre sous-réseau transitera par cette passerelle et utilisera l'adresse IP statique que vous avez réservée à l'étape précédente.
```
gcloud compute routers nats create NAT_NAME \
    --router=ROUTER_NAME \
    --region=REGION \
    --nat-custom-subnet-ip-ranges=SUBNET_NAME \
    --nat-external-ip-pool=ORIGIN_IP_NAME
  
```
Dans la commande ci-dessus, remplacez :
- NAT_NAME par le nom de la ressource de passerelle Cloud NAT que vous souhaitez créer.
- ROUTER_NAME par le nom de votre Cloud Router.
- REGION par la région dans laquelle vous souhaitez créer une passerelle NAT.
- ORIGIN_IP_NAME par le nom de la ressource d'adresse IP réservée que vous avez créée à l'étape précédente.
Définissez le paramètre de sortie de l'accès au VPC sans serveur sur all-traffic.

Par défaut, les services App Engine qui utilisent l'accès au VPC sans serveur n'envoient que du trafic interne à votre réseau VPC. Pour envoyer du trafic avec des destinations externes à votre réseau VPC afin qu'il dispose de l'adresse IP statique que vous avez spécifiée, vous devez modifier le paramètre de sortie.
Spécifiez le paramètre de sortie dans le fichier app.yaml de votre service :
```
vpc_access_connector:
  name: projects/PROJECT_ID/locations/REGION/connectors/CONNECTOR_NAME
  egress_setting: all-traffic
```
Remplacez :
- PROJECT_ID par l'ID de votre projet Google Cloud
- REGION par la région dans laquelle se trouve le connecteur ;
- CONNECTOR_NAME par le nom de votre connecteur.
Déployez le service :
```
 gcloud app deploy
```