Visão geral

O Cloud Run functions possibilita que você se conecte diretamente à rede VPC, permitindo que as funções acessem instâncias de VM do Compute Engine, instâncias do Memorystore e outros recursos com um endereço IP interno.

Neste laboratório, você vai usar o acesso VPC sem servidor para conectar uma função à rede VPC e acessar dados em uma instância do Memorystore em execução na rede. Você também vai usar o conector para acessar um servidor da Web em execução em uma instância da VM na rede.

Objetivos

Neste laboratório, você vai:

• Configurar uma instância do Memorystore para Redis.
• Criar um conector de acesso VPC sem servidor para ativar o acesso VPC sem servidor.
• Escrever uma função orientada por eventos do Pub/Sub que use o conector para armazenar o conteúdo da mensagem no banco de dados do Redis.
• Escrever uma função HTTP para encontrar dados do banco de dados do Redis usando o conector e retornar os dados da mensagem em uma resposta HTTP.
• Escrever uma função HTTP para acessar um servidor da Web em execução em uma instância da VM na rede VPC.

Confira uma visão geral de alto nível dos recursos a serem criados neste laboratório:

Configuração e requisitos

Antes de clicar no botão "Começar o laboratório"

Este laboratório prático do Google Skills permite que você realize as atividades em um ambiente real de nuvem, não em uma simulação ou demonstração. Você vai receber novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.

O que é necessário

Veja os requisitos para concluir o laboratório:

• Acesso a um navegador de Internet padrão (recomendamos o Chrome).
• Tempo disponível para concluir as atividades

Ative o Google Cloud Shell

O Google Cloud Shell é uma máquina virtual com ferramentas de desenvolvimento. Ele tem um diretório principal permanente de 5 GB e é executado no Google Cloud.

O Cloud Shell oferece acesso de linha de comando aos recursos do Google Cloud.

1. No console do Cloud, clique no botão "Abrir o Cloud Shell" na barra de ferramentas superior direita.

   

2. Clique em Continuar.

O provisionamento e a conexão do ambiente podem demorar um pouco. Quando você estiver conectado, já estará autenticado, e o projeto estará definido com seu PROJECT_ID. Exemplo:

A gcloud é a ferramenta de linha de comando do Google Cloud. Ela vem pré-instalada no Cloud Shell e aceita preenchimento com tabulação.

• Para listar o nome da conta ativa, use este comando:

Saída:

Exemplo de saída:

• Para listar o ID do projeto, use este comando:

Saída:

Exemplo de saída:

Tarefa 1. Ativar APIs

Antes de criar o Cloud Run functions, você precisa ativar as APIs relevantes.

1. Para definir as variáveis de ambiente ID do projeto e Região, ative o Cloud Shell e execute os seguintes comandos:

   PROJECT_ID=$(gcloud config get-value project) REGION={{{project_0.default_region|set at lab start}}}

2. Execute os seguintes comandos para ativar todos os serviços necessários:

   gcloud services enable \ artifactregistry.googleapis.com \ cloudfunctions.googleapis.com \ cloudbuild.googleapis.com \ eventarc.googleapis.com \ run.googleapis.com \ logging.googleapis.com \ pubsub.googleapis.com \ redis.googleapis.com \ vpcaccess.googleapis.com

Tarefa 2. Configurar uma instância do Memorystore para Redis

O Memorystore é um serviço do Google Cloud que oferece uma solução de cache em memória totalmente gerenciada, altamente disponível, escalonável e segura para Redis e Memcached.

Nesta tarefa, você vai configurar uma instância do Memorystore para Redis no seu projeto do Google Cloud. Essa instância será usada pelo Cloud Run functions para armazenar os dados que você vai desenvolver em uma tarefa posterior do laboratório.

Criar a instância do Memorystore

1. Defina uma variável de ambiente para o nome da instância do Memorystore:

   REDIS_INSTANCE=customerdb

2. Para criar uma instância do Memorystore para Redis de 2 GiB, execute o seguinte comando:

   gcloud redis instances create $REDIS_INSTANCE \ --size=2 --region=$REGION \ --redis-version=redis_6_x A instância do Memorystore para Redis será criada em alguns minutos. Continue e conclua a Tarefa 3 para configurar o acesso VPC sem servidor e, em seguida, volte para concluir as etapas restantes desta tarefa após a criação da instância do Redis.

3. Para visualizar os detalhes da instância depois de criá-la, execute o seguinte comando:

   gcloud redis instances describe $REDIS_INSTANCE --region=$REGION

Criar variáveis de ambiente

1. Salve o endereço IP do host da instância do Memorystore em uma variável de ambiente

   REDIS_IP=$(gcloud redis instances describe $REDIS_INSTANCE --region=$REGION --format="value(host)"); echo $REDIS_IP

2. Salve a porta da instância do Memorystore em uma variável de ambiente:

   REDIS_PORT=$(gcloud redis instances describe $REDIS_INSTANCE --region=$REGION --format="value(port)"); echo $REDIS_PORT Você vai usar os valores de host e porta em uma tarefa subsequente para se conectar à instância.

Clique em Verificar meu progresso para conferir o objetivo. Configurar uma instância do Memorystore para Redis

Tarefa 3. Configurar o acesso VPC sem servidor

Para enviar solicitações do Cloud Run functions para recursos na rede VPC e receber as respostas correspondentes sem usar a Internet pública, você precisa configurar o acesso VPC sem servidor.

Configurar um conector de acesso VPC sem servidor

1. No menu de navegação do console do Google Cloud (), em Rede, clique em Rede VPC e selecione Acesso VPC sem servidor.

2. Para criar um conector de acesso VPC sem servidor, clique em Criar conector.

3. Em Nome do conector, digite test-connector

4. Em Região, selecione .

5. Em Sub-rede, selecione Intervalo de IP personalizado.

6. Em Intervalo de IP, digite 10.8.0.0

   Observação: o intervalo de IP precisa ser uma sub-rede interna /28 não reservada especificada na notação CIDR. Esse intervalo de IP não pode se sobrepor a qualquer reserva de endereço IP atual na rede VPC. Esse intervalo de endereços IP é usado no escalonamento para criar instâncias de conector adicionais.

   A região especificada para o conector precisa ser a mesma em que o Cloud Run functions está hospedado.

7. Não altere as configurações restantes e clique em Criar.

   Uma marca de seleção verde será exibida ao lado do nome do conector quando ele estiver pronto para uso.

8. Para verificar os detalhes do conector, execute este comando no Cloud Shell:

   gcloud compute networks vpc-access connectors \ describe test-connector \ --region $REGION

Clique em Verificar meu progresso para conferir o objetivo. Criar um conector de acesso VPC sem servidor

Tarefa 4. Criar uma função orientada por eventos para o Pub/Sub

Agora que o conector de acesso VPC sem servidor foi criado, você pode desenvolver uma função para acessar os dados na instância do Memorystore para Redis usando o conector.

Nesta tarefa, você vai criar uma função do Pub/Sub orientada por eventos no Python para armazenar e buscar dados de e para a instância do Memorystore.

Criar um tópico do Pub/Sub

1. Primeiro, você precisa criar um tópico que a função vai detectar para as mensagens. Defina uma variável de ambiente para o nome do tópico:

   TOPIC=add_redis

2. Para criar um tópico, execute o seguinte comando:

   gcloud pubsub topics create $TOPIC

Escrever o código da função

1. Execute o comando abaixo para criar a pasta e os arquivos da função, e navegue até a pasta:

   mkdir ~/redis-pubsub && cd $_ touch main.py && touch requirements.txt

2. Clique no botão Abrir editor na barra de ferramentas do Cloud Shell. (É possível alternar entre o Cloud Shell e o editor de código usando os ícones de Abrir editor e Abrir terminal, conforme necessário).

3. No editor do Cloud Shell, selecione a pasta redis-pubsub.

4. No Editor, adicione o seguinte código ao arquivo redis-pubsub/main.py:

   import os import base64 import json import redis import functions_framework redis_host = os.environ.get('REDISHOST', 'localhost') redis_port = int(os.environ.get('REDISPORT', 6379)) redis_client = redis.StrictRedis(host=redis_host, port=redis_port) # Triggered from a message on a Pub/Sub topic. @functions_framework.cloud_event def addToRedis(cloud_event): # The Pub/Sub message data is stored as a base64-encoded string in the cloud_event.data property # The expected value should be a JSON string. json_data_str = base64.b64decode(cloud_event.data["message"]["data"]).decode() json_payload = json.loads(json_data_str) response_data = "" if json_payload and 'id' in json_payload: id = json_payload['id'] data = redis_client.set(id, json_data_str) response_data = redis_client.get(id) print(f"Added data to Redis: {response_data}") else: print("Message is invalid, or missing an 'id' attribute")

5. Para especificar as dependências do código da função, adicione o conteúdo a seguir ao arquivo redis-pubsub/requirements.txt.

   functions-framework==3.2.0 redis==4.3.4

Implantar e testar a função

1. Para implantar a função, execute no Cloud Shell o seguinte comando:

   gcloud functions deploy python-pubsub-function \ --runtime=python310 \ --region=$REGION \ --source=. \ --entry-point=addToRedis \ --trigger-topic=$TOPIC \ --vpc-connector projects/$PROJECT_ID/locations/$REGION/connectors/test-connector \ --set-env-vars REDISHOST=$REDIS_IP,REDISPORT=$REDIS_PORT

2. No pop-up Vincular o papel à conta de serviço, insira n.

   A função é implantada com um tópico de gatilho do Pub/Sub, o conector de acesso VPC sem servidor e variáveis de ambiente que fornecem à função o endereço IP do host e a porta da instância do Memorystore para Redis. Observação: se você vir um erro de permissões, aguarde alguns minutos e tente a implantação de novo.

3. Para testar a função, publique uma mensagem no tópico:

   gcloud pubsub topics publish $TOPIC --message='{"id": 1234, "firstName": "Lucas" ,"lastName": "Sherman", "Phone": "555-555-5555"}'

Visualizar os registros da função

1. No console do Google Cloud, navegue até a página de visão geral do Cloud Run functions e clique no nome python-pubsub-function.

2. Clique em Registros.

3. Verifique a entrada de registro que indica que o payload de dados JSON enviado na mensagem do Pub/Sub foi adicionado ao Redis.

   

Clique em Verificar meu progresso para conferir o objetivo. Criar uma função orientada por eventos para o Pub/Sub

Tarefa 5. Criar uma função HTTP

Nesta tarefa, você vai criar uma função HTTP em Python para consultar a instância do Memorystore para Redis e retornar dados com base em um identificador transmitido na solicitação.

Escrever o código da função

1. Execute o comando abaixo para criar uma pasta e arquivos para a função HTTP, e navegue até a pasta:

   mkdir ~/redis-http && cd $_ touch main.py && touch requirements.txt

2. Na barra de ferramentas do Cloud Shell, clique em Abrir editor.

3. No editor do Cloud Shell, selecione a pasta redis-http.

4. No editor, adicione o seguinte código ao arquivo redis-http/main.py:

   import os import redis from flask import request import functions_framework redis_host = os.environ.get('REDISHOST', 'localhost') redis_port = int(os.environ.get('REDISPORT', 6379)) redis_client = redis.StrictRedis(host=redis_host, port=redis_port) @functions_framework.http def getFromRedis(request): response_data = "" if request.method == 'GET': id = request.args.get('id') try: response_data = redis_client.get(id) except RuntimeError: response_data = "" if response_data is None: response_data = "" return response_data

5. Para especificar as dependências do código da função, adicione as seguintes linhas ao arquivo redis-http/requirements.txt:

   functions-framework==3.2.0 redis==4.3.4 Separe as dependências de cada função para que apenas os módulos necessários sejam carregados no momento da inicialização da instância da função. Isso reduz a latência da função durante inicializações a frio.

Implantar e testar a função

1. Para implantar a função, execute no Cloud Shell o seguinte comando:

   gcloud functions deploy http-get-redis \ --gen2 \ --runtime python310 \ --entry-point getFromRedis \ --source . \ --region $REGION \ --trigger-http \ --timeout 600s \ --max-instances 1 \ --vpc-connector projects/$PROJECT_ID/locations/$REGION/connectors/test-connector \ --set-env-vars REDISHOST=$REDIS_IP,REDISPORT=$REDIS_PORT \ --no-allow-unauthenticated Observação: se você vir um erro de permissões, aguarde alguns minutos e tente de novo a implantação.

2. Depois de implantar a função, recupere o URI HTTP dela e armazene-o em uma variável de ambiente:

   FUNCTION_URI=$(gcloud functions describe http-get-redis --gen2 --region $REGION --format "value(serviceConfig.uri)"); echo $FUNCTION_URI

3. Para testar a função, execute o seguinte comando curl:

   curl -H "Authorization: bearer $(gcloud auth print-identity-token)" "${FUNCTION_URI}?id=1234" Observação: transmita o mesmo valor de parâmetro id usado no teste do gatilho da função do Pub/Sub na tarefa anterior.

4. Verifique se a resposta da função HTTP corresponde aos dados JSON armazenados anteriormente na instância do Redis:

   {"id": 1234, "firstName": "Lucas" ,"lastName": "Sherman", "Phone": "555-555-5555"}

Clique em Verificar meu progresso para conferir o objetivo. Criar uma função HTTP para se conectar ao Redis

Tarefa 6. Conectar-se a uma instância da VM de uma função HTTP

Para se conectar a recursos na rede VPC usando o Cloud Run functions, é necessário usar um conector de acesso VPC sem servidor. Nesta tarefa, você vai criar uma VM e uma função HTTP para se conectar à instância da VM.

Criar um script de inicialização da VM

1. Antes de criar uma VM, no Cloud Shell, faça download de um script de inicialização que instale e execute um servidor da Web simples:

   gcloud storage cp gs://cloud-training/CBL492/startup.sh .

2. Para visualizar o conteúdo do script de inicialização da VM, execute:

   cat startup.sh

Criar uma VM

1. Defina uma variável de ambiente para a zona em que a VM será criada:

   ZONE={{{project_0.default_zone|set at lab start}}}

2. Para criar uma VM com o script de inicialização, execute o seguinte comando:

   gcloud compute instances create webserver-vm \ --image-project=debian-cloud \ --image-family=debian-11 \ --metadata-from-file=startup-script=./startup.sh \ --machine-type e2-standard-2 \ --tags=http-server \ --scopes=https://www.googleapis.com/auth/cloud-platform \ --zone $ZONE

3. Adicione uma regra de firewall à rede VPC para permitir que o tráfego HTTP acesse a VM:

   gcloud compute --project=$PROJECT_ID \ firewall-rules create default-allow-http \ --direction=INGRESS \ --priority=1000 \ --network=default \ --action=ALLOW \ --rules=tcp:80 \ --source-ranges=0.0.0.0/0 \ --target-tags=http-server

4. Para verificar se a VM foi criada e está em execução, vá ao console do Google Cloud, acesse Compute Engine e clique em Instâncias de VM.

   Deve haver uma VM com uma marca de seleção verde para indicar que ela está em execução:

   

5. Salve os endereços IP internos e externos da VM em variáveis de ambiente. Essas variáveis serão usadas mais tarde para testar a função.

   VM_INT_IP=$(gcloud compute instances describe webserver-vm --format='get(networkInterfaces[0].networkIP)' --zone $ZONE); echo $VM_INT_IP VM_EXT_IP=$(gcloud compute instances describe webserver-vm --format='get(networkInterfaces[0].accessConfigs[0].natIP)' --zone $ZONE); echo $VM_EXT_IP

Escrever o código da função

Nesta subtarefa, você vai escrever a função HTTP que, quando acionada, vai se conectar à VM que você criou.

1. Execute o comando abaixo para criar uma pasta e arquivos para o código da função HTTP, e navegue até a pasta:

   mkdir ~/vm-http && cd $_ touch main.py && touch requirements.txt

2. Na barra de ferramentas do Cloud Shell, clique em Abrir editor.

3. No editor do Cloud Shell, selecione a pasta vm-http.

4. No editor, adicione o seguinte código ao arquivo vm-http/main.py:

   import functions_framework import requests @functions_framework.http def connectVM(request): resp_text = "" if request.method == 'GET': ip = request.args.get('ip') try: response_data = requests.get(f"http://{ip}") resp_text = response_data.text except RuntimeError: print ("Error while connecting to VM") return resp_text A função faz uma solicitação HTTP GET ao servidor da Web em execução na VM. O endereço IP do endpoint do servidor da Web é transmitido para a função como um parâmetro de consulta no URL da função.

5. No editor, adicione o seguinte ao arquivo vm-http/requirements.txt:

   functions-framework==3.2.0 Werkzeug==2.3.7 flask==2.1.3 requests==2.28.1

Implantar a função

1. Para implantar a função, execute no Cloud Shell o seguinte comando:

   gcloud functions deploy vm-connector \ --runtime python310 \ --entry-point connectVM \ --source . \ --region $REGION \ --trigger-http \ --timeout 10s \ --max-instances 1 \ --no-allow-unauthenticated

2. Depois de implantar a função, extraia o URL dela executando o seguinte comando:

   FUNCTION_URI=$(gcloud functions describe vm-connector --region $REGION --format='value(url)'); echo $FUNCTION_URI

Testar a função

1. Teste a função fornecendo o endereço IP externo da VM no URL da função:

   curl -H "Authorization: bearer $(gcloud auth print-identity-token)" "${FUNCTION_URI}?ip=$VM_EXT_IP"

   O comando deve retornar a resposta HTML do servidor da Web em execução na VM:

   <html><body><p>Script de inicialização do Linux de um arquivo local.</p></body></html> Por padrão, o Cloud Run functions pode acessar IPs externos ou URLs públicos. Para mudar esse comportamento, você pode modificar as configurações de saída da função para rotear o tráfego dela pela rede VPC usando um conector.

2. Repita o teste fornecendo o endereço IP interno da VM ao URL da função:

   curl -H "Authorization: bearer $(gcloud auth print-identity-token)" "${FUNCTION_URI}?ip=$VM_INT_IP"

   A função expira depois de aproximadamente 10 segundos, porque, por padrão, a função não pode acessar a VM pelo endereço IP interno.

   É informado um erro:

   upstream request timeout

Usar o conector de VPC

Para acessar a VM ou outros recursos internos na rede VPC da função, você precisa usar um conector de acesso VPC sem servidor.

1. Reative a API Cloud Functions:

   gcloud services disable cloudfunctions.googleapis.com gcloud services enable cloudfunctions.googleapis.com

2. Reimplante a função HTTP definindo o conector de VPC que você criou anteriormente neste laboratório:

   gcloud functions deploy vm-connector \ --runtime python310 \ --entry-point connectVM \ --source . \ --region $REGION \ --trigger-http \ --timeout 10s \ --max-instances 1 \ --no-allow-unauthenticated \ --vpc-connector projects/$PROJECT_ID/locations/$REGION/connectors/test-connector Observação: se você vir um erro de permissões, aguarde alguns minutos e tente de novo a implantação.

3. Depois de reimplantar a função, teste a conexão interna com a VM:

   curl -H "Authorization: bearer $(gcloud auth print-identity-token)" "${FUNCTION_URI}?ip=$VM_INT_IP"

   A função agora retorna a resposta HTML do servidor da Web em execução na VM:

   <html><body><p>Linux startup script from a local file.</p></body></html>

Clique em Verificar meu progresso para conferir o objetivo. Criar uma função HTTP para se conectar a uma VM

Parabéns!

Neste laboratório, você criou uma instância do Memorystore para Redis e configurou o acesso VPC sem servidor para conectar o Cloud Run functions à instância na rede VPC. Em seguida, você criou uma função orientada por eventos do Pub/Sub para se conectar à instância do Redis e armazenar o conteúdo da mensagem. Você também criou uma função HTTP para se conectar à instância do Redis e buscar os dados dela com base em um identificador transmitido na solicitação à função. Por fim, você criou uma VM e usou um conector de acesso VPC sem servidor para conectar uma função HTTP à VM pelo endereço IP interno dela.

Próximas etapas/Saiba mais

Para mais informações sobre o Memorystore, consulte a documentação:

• Memorystore

Para mais informações sobre o acesso VPC sem servidor, consulte a documentação:

• Leitura: Como configurar o acesso VPC sem servidor
• Acesso VPC sem servidor

Copyright 2026 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de empresas e produtos podem ser marcas registradas das empresas a que estão associados.