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

Por padrão, os serviços de saída no ambiente padrão do App Engine, como as APIs URL Fetch, Sockets e Mail, usam um pool regional de endereços IP dinâmicos compartilhados em todas as cargas de trabalho sem servidor. Os intervalos de endereços IP nesse pool mudam rotineiramente, então duas chamadas sequenciais do mesmo aplicativo podem se originar de endereços IP diferentes.

Como outras cargas de trabalho sem servidor compartilham esse pool de endereços IP padrão, não dependa dele quando precisar de um endereço IP de origem previsível ou de uma reputação de IP isolada. Em vez disso, configure um endereço IP de saída estático para o serviço nas seguintes situações:

• Você se conecta a um banco de dados ou API externa que usa uma lista de permissões de endereço IP ou um firewall.
• Você se conecta a endpoints externos sensíveis à reputação, como gateways de pagamento, bancos de dados hospedados ou APIs de parceiros protegidas por firewalls de aplicativos da Web (WAFs) de terceiros. O tráfego ruidoso de outro locatário no pool de IPs compartilhados padrão pode degradar a reputação do IP e fazer com que WAFs externos bloqueiem ou limitem suas solicitações.
• Você executa verificações de rede autorizadas, enumeração de portas, impressão digital de host, sondagem de vulnerabilidades, extração de dados da Web ou cargas de trabalho de teste de carga.

Aviso: não execute verificação de rede, enumeração de portas, impressão digital de host, sondagem de vulnerabilidade, raspagem de dados da Web ou teste de carga no pool de endereços IP compartilhados padrão. Esse tráfego degrada a reputação do IP compartilhado, pode interromper o serviço para outros clientes em violação da Google Cloud Política de Uso Aceitável e pode fazer com que o Google limite ou suspenda sua carga de trabalho.

Se você só precisar procurar os intervalos de endereços IP associados ao tráfego de saída padrão do serviço, poderá encontrar os intervalos de endereços IP atuais que incluem endereços IP do App Engine.

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 usando dois arquivos JSON publicados pelo Google:

• O Google publica uma lista de endereços IP de propriedade do Google em goog.json.

• O Google também publica uma lista de intervalos de endereços IP externo globais e regionais disponíveis para os recursos do Google Cloud dos clientes em cloud.json.

A remoção de todos os intervalos em cloud.json daqueles em goog.json resulta em um grande conjunto de endereços IP usados pelas APIs globais do Google e outros serviços do Google, incluindo produtos voltados para o cliente fora do Google Cloud. 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()

Observação : no passado, o Google Cloud publicou uma lista de intervalos de endereços IP no registro TXT do DNS _spf.google.com (e os registros a que ele se referia). Embora esse registro TXT do DNS continue sendo preciso para fins de SPF, ele não contém o conjunto completo de possíveis intervalos de endereços IP usados pelas APIs e serviços do Google.

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

Para configurar um endereço IP estático para o serviço do ambiente padrão do App Engine, encaminhe o tráfego de saída para uma rede de nuvem privada virtual (VPC) usando a saída VPC direta (pré-lançamento) ou o acesso VPC sem servidor com o Cloud Router e o Cloud NAT. Adicionar um gateway do Cloud NAT à rede VPC encaminha o tráfego de saída do App Engine pelo endereço IP estático reservado.

Se o serviço for escalonado para muitas instâncias ou abrir muitas conexões simultâneas, como durante a verificação de rede autorizada, atribua vários endereços IP estáticos ao Cloud NAT. Também é possível aumentar o número mínimo de portas por instância ou ativar a alocação dinâmica de portas para evitar o esgotamento de portas. Saiba mais sobre como os gateways do Cloud NAT usam endereços IP e portas.

Direcionar seu tráfego pelo Cloud NAT não adiciona um salto extra 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 do Cloud NAT ou pelo Cloud Router.

Observação : o acesso VPC sem servidor e o Cloud NAT podem gerar custos. Consulte os preços do acesso VPC sem servidor e os preços do Cloud NAT. Para rotear solicitações de saída pelo Cloud NAT no ambiente flexível do App Engine, consulte Enviar solicitações externas sem um endereço IP externo.

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.

1. Verifique se você tem o papel roles/compute.networkAdmin ou um papel personalizado com as mesmas permissões.

2. 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.

3. 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.

4. 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;

5. 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 é contabilizado nas cotas de endereços IP estáticos do 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

6. 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;

7. 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 do projeto do Google Cloud .
   • REGION pela região em que o conector está;
   • CONNECTOR_NAME pelo name do conector.

Implante o serviço:

 gcloud app deploy