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

Os serviços de saída no ambiente padrão do App Engine, como as APIs URL Fetch, Sockets e Mail, usam um grande conjunto de endereços IP. Os intervalos de endereços IP neste conjunto estão sujeitos a alterações de rotina. Na verdade, duas chamadas de API sequenciais da mesma aplicação podem parecer ter origem em dois endereços IP diferentes.

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

Endereços IP para serviços do App Engine

Pode encontrar os intervalos de endereços IP atuais para os seus serviços do App Engine com base nas informações de intervalos de IP publicadas pela Google:

• A Google publica a lista completa de intervalos de IP que disponibiliza aos utilizadores na Internet em goog.json.

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

Os endereços IP usados pelas APIs e pelos serviços Google enquadram-se na lista de intervalos calculados subtraindo todos os intervalos em cloud.json aos intervalos em goog.json. Estas listas são atualizadas com frequência.

Pode usar o seguinte script Python para criar uma lista de intervalos de endereços IP que incluem os usados pelas APIs e pelos serviços Google.

Para informações sobre a execução deste script, consulte o artigo 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()

Nota: anteriormente, Google Cloud publicou uma lista de intervalos de endereços IP no registo TXT de DNS (e nos registos a que fazia referência)._spf.google.com Embora este registo TXT de DNS continue a ser preciso para fins de SPF, não contém o conjunto completo de intervalos de endereços IP possíveis usados pelas APIs e pelos serviços Google.

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

Para configurar um endereço IP estático para o seu serviço do 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, pode enviar tráfego de saída para a sua rede da nuvem virtual privada (VPC). Ao usar um gateway de tradução de endereços de rede (NAT) na sua VPC, pode encaminhar o tráfego do App Engine através de um endereço IP dedicado.

O encaminhamento do seu tráfego através do Cloud NAT não causa um salto adicional na sua pilha de rede, uma vez que o gateway do Cloud NAT e o Cloud Router fornecem apenas um plano de controlo, e os pacotes não passam pelo gateway do Cloud NAT nem pelo Cloud Router.

Nota: o Acesso a VPC sem servidor e o Cloud NAT podem incorrer em custos. Reveja os preços do Acesso a VPC sem servidor e os preços do NAT na nuvem.

Os passos seguintes mostram como configurar um endereço IP estático de saída para o serviço do ambiente padrão do App Engine.

1. Certifique-se de que tem a função roles/compute.networkAdmin ou uma função personalizada com as mesmas autorizações.

2. Crie uma sub-rede na sua rede de VPC para o tráfego do App Engine. Isto garante que outros recursos na sua rede VPC não podem 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 com um nome que quer atribuir à sub-rede.
   • RANGE com o intervalo de IPs no formato CIDR que quer atribuir a esta sub-rede (por exemplo, 10.124.0.0/28)
   • NETWORK_NAME com o nome da sua rede VPC.
   • REGION com a região do seu serviço do App Engine.

3. Associe o serviço do App Engine à sub-rede.

   Siga o guia Estabelecer ligação a uma rede VPC e especifique o nome da sub-rede que criou no passo anterior para a sub-rede do conetor.

4. Crie um novo Cloud Router. O Cloud Router é um componente do plano de controlo necessário para a NAT na nuvem.

   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 quer criar.
   • NETWORK_NAME com o nome da sua rede VPC.
   • REGION com a região na qual quer criar um gateway NAT.

5. Reserve um endereço IP estático.

   Este é o endereço que o seu serviço vai 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 está associado é eliminado e recriado. Este endereço IP conta para as quotas de endereços IP estáticos no seu Google Cloud projeto.

   gcloud compute addresses create ORIGIN_IP_NAME \
       --region=REGION

   No comando acima, substitua:

   • ORIGIN_IP_NAME com o nome que quer atribuir ao recurso de endereço IP.
   • REGION com a região que vai executar o router Cloud NAT. Idealmente, a mesma região que o seu serviço do App Engine para minimizar a latência e os custos de rede.

   Use o comando compute addresses describe para ver o resultado:

   gcloud compute addresses describe ORIGIN_IP_NAME

6. Crie um gateway NAT da nuvem e especifique o seu endereço IP.

   O tráfego originário da sua sub-rede passa por este gateway e usa o endereço IP estático que reservou no passo 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 quer criar.
   • ROUTER_NAME com o nome do seu Cloud Router.
   • REGION com a região na qual quer criar um gateway NAT.
   • ORIGIN_IP_NAME com o nome do recurso de endereço IP reservado que criou no passo anterior.

7. Defina a definição de saída do acesso a VPC sem servidor como all-traffic.

   Por predefinição, os serviços do App Engine que usam o Acesso a VPC sem servidor só enviam tráfego interno para a sua rede VPC. Para enviar tráfego com destinos externos para a sua rede VPC, de modo que tenha o endereço IP estático que especificou, tem de alterar a definição de saída.

   Especifique a definição de saída no ficheiro app.yaml para o seu serviço:

   vpc_access_connector:
   name: projects/PROJECT_ID/locations/REGION/connectors/CONNECTOR_NAME
   egress_setting: all-traffic

   Substituição:

   • PROJECT_ID com o ID do seu Google Cloud projeto.
   • REGION com a região em que o conector se encontra.
   • CONNECTOR_NAME com o nome do seu conetor.

Implemente o serviço:

 gcloud app deploy