Endereços IP de saída para serviços do App Engine

Os serviços de saída, como as APIs URL Fetch, Sockets e Mail, utilizam um grande pool de endereços IP. Os intervalos de endereços IP nesse conjunto estão sujeitos a alterações de rotina. Na verdade, duas chamadas de API sequenciais do mesmo aplicativo podem parecer originadas de dois endereços IP diferentes.

Se você precisar saber os endereços IP associados ao tráfego de saída do serviço, poderá encontrar os intervalos de endereços IP atuais do serviço ou configurar um endereço IP estático para o serviço.

Endereços IP para serviços do App Engine

É possível encontrar os intervalos de endereços IP atuais dos serviços do App Engine com base nas informações de intervalos de IP que o Google publica:

O Google publica a lista completa de intervalos de IP que disponibiliza para usuários na Internet em goog.json.
O Google também publica uma lista de intervalos de endereços IP externos globais e regionais disponíveis para os recursos do Google Cloud dos clientes em cloud.json.

Os endereços IP usados pelas APIs e serviços do Google se encaixam na lista de intervalos calculados removendo todos os intervalos em cloud.json daqueles em goog.json. Essas listas são atualizadas com frequência.

É possível usar o script Python a seguir para criar uma lista de intervalos de endereços IP que incluem aqueles usados pelas APIs e serviços do Google.

Para mais informações sobre como executar esse script, consulte Como executar.

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()

Configurar um endereço IP de saída estático

Para configurar um endereço IP estático para o serviço de ambiente padrão do App Engine, use o acesso VPC sem servidor com o Cloud Router e o Cloud NAT. Ao usar o acesso VPC sem servidor, é possível enviar tráfego de saída para a rede de nuvem privada virtual (VPC, na sigla em inglês). Ao usar um gateway de conversão de endereços de rede (NAT, na sigla em inglês) na VPC, é possível rotear o tráfego do App Engine por um endereço IP dedicado.

Rotear o tráfego pelo Cloud NAT não causa um salto adicional na pilha de rede, porque o gateway do Cloud NAT e o Cloud Router fornecem apenas um plano de controle e os pacotes não passam pelo gateway NAT ou pelo Cloud Router.

Não é possível configurar endereços IP de saída estáticos para o tráfego enviado usando o serviço de busca de URL. O tráfego enviado usando o serviço de busca de URL continuará usando o pool de endereços IP públicos. Se você quiser que todo o tráfego de saída use um endereço IP estático, desative o padrão de busca de URL e interrompa qualquer uso explícito da biblioteca urlfetch.

As etapas a seguir mostram como configurar um endereço IP de saída estático para o serviço de ambiente padrão do App Engine.

Verifique se você tem o papel roles/compute.networkAdmin ou um papel personalizado com as mesmas permissões.
Crie uma sub-rede dentro da rede VPC para o tráfego do App Engine. Isso garante que outros recursos na rede VPC não possam usar o endereço IP estático.
```
gcloud compute networks subnets create SUBNET_NAME \
    --range=RANGE \
    --network=NETWORK_NAME \
    --region=REGION
```
No comando acima, substitua:
- SUBNET_NAME por um nome que você quer dar à sub-rede;
- RANGE pelo intervalo de IP no formato CIDR que você quer atribuir a essa sub-rede (por exemplo, 10.124.0.0/28);
- NETWORK_NAME pelo nome da rede VPC;
- REGION pela região do serviço do App Engine.
Conecte o serviço do App Engine à sub-rede.

Siga o guia Como se conectar a uma rede VPC e especifique o nome da sub-rede criada na etapa anterior para a sub-rede do conector.
Crie um novo Cloud Router. O Cloud Router é um componente do plano de controle necessário para o Cloud NAT.
```
gcloud compute routers create ROUTER_NAME \
    --network=NETWORK_NAME \
    --region=REGION
```
No comando acima, substitua:
- ROUTER_NAME com um nome para o recurso do Cloud Router que você quer criar.
- NETWORK_NAME pelo nome da rede VPC;
- REGION pela região em que você quer criar um gateway NAT;
Reservar um endereço IP estático

Esse é o endereço que o serviço usará para enviar tráfego de saída. Um recurso de endereço IP reservado retém o endereço IP subjacente quando o recurso ao qual ele está associado é excluído e recriado: Esse endereço IP conta para as cotas de endereço IP estático no projeto do Google Cloud.
```
gcloud compute addresses create ORIGIN_IP_NAME \
    --region=REGION
```
No comando acima, substitua:
- ORIGIN_IP_NAME pelo nome que você quer atribuir ao recurso de endereço IP.
- REGION pela região que executará o roteador do Cloud NAT. Idealmente, a mesma região do serviço do App Engine para minimizar os custos de latência e de rede.
Use o comando compute addresses describe para ver o resultado:
```
gcloud compute addresses describe ORIGIN_IP_NAME
```
Crie um gateway do Cloud NAT e especifique o endereço IP.

O tráfego proveniente da sub-rede passará por esse gateway e usará o endereço IP estático reservado na etapa anterior.
```
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
  
```
No comando acima, substitua:
- NAT_NAME com um nome para o recurso de gateway do Cloud NAT que você quer criar.
- ROUTER_NAME com o nome do seu Cloud Router
- REGION pela região em que você quer criar um gateway NAT;
- ORIGIN_IP_NAME pelo nome do recurso de endereço IP reservado criado na etapa anterior;
Defina a configuração de saída do acesso VPC sem servidor como all-traffic.

Por padrão, os serviços do App Engine que usam o acesso VPC sem servidor enviam tráfego interno apenas para a rede VPC. Para enviar tráfego com destinos externos para a rede VPC para que ela tenha o endereço IP estático especificado, altere a configuração de saída.
Especifique a configuração de saída no arquivo app.yaml do serviço:
```
vpc_access_connector:
  name: projects/PROJECT_ID/locations/REGION/connectors/CONNECTOR_NAME
  egress_setting: all-traffic
```
Substitua:
- PROJECT_ID pelo ID de projeto do Google Cloud;
- REGION pela região em que o conector está;
- CONNECTOR_NAME pelo nome do conector.
Implante o serviço:
```
 gcloud app deploy
```