1. Introdução
Visão geral
Para proteger o tráfego de rede dos serviços e aplicativos, muitas organizações usam uma rede de nuvem privada virtual (VPC) no Google Cloud com controles de perímetro para evitar a exfiltração de dados. Uma rede VPC é uma versão virtual de uma rede física, implementada dentro da rede de produção do Google. Uma rede VPC oferece conectividade para suas instâncias de máquina virtual (VM) do Compute Engine, balanceadores de carga de rede de passagem interna nativos e sistemas de proxy para balanceadores de carga de aplicativo internos, se conecta a redes locais usando túneis do Cloud VPN e anexos de VLAN para o Cloud Interconnect e distribui o tráfego dos balanceadores de carga externos do Google Cloud para back-ends.
Ao contrário das VMs, os serviços do Cloud Run não são associados a nenhuma rede VPC específica por padrão. Este codelab demonstra como mudar as configurações de entrada (conexões de entrada) para que apenas o tráfego de uma VPC possa acessar um serviço do Cloud Run (por exemplo, um serviço de back-end). Além disso, este codelab mostra como fazer com que um segundo serviço (por exemplo, um serviço de front-end) acesse o serviço de back-end do Cloud Run por uma VPC e continue tendo acesso à Internet pública.
Neste exemplo, o serviço de back-end do Cloud Run retorna "hello world". O serviço de front-end do Cloud Run fornece um campo de entrada na interface para coletar um URL. Em seguida, o serviço de front-end faz uma solicitação GET para esse URL (por exemplo, o serviço de back-end), transformando isso em uma solicitação de serviço para serviço (em vez de uma solicitação de navegador para serviço). Quando o serviço de front-end consegue alcançar o back-end, a mensagem "Hello World" aparece no navegador. Em seguida, você vai aprender a fazer uma chamada para https://curlmyip.org e recuperar o endereço IP do seu serviço de front-end.
O que você vai aprender
- Como permitir apenas o tráfego de uma VPC para seu serviço do Cloud Run
- Como configurar a saída em um serviço do Cloud Run (por exemplo, front-end) para se comunicar com um serviço do Cloud Run somente de entrada interna (por exemplo, back-end), mantendo o acesso à Internet pública para o serviço de front-end.
2. Configuração e requisitos
Pré-requisitos
- Você fez login no console do Cloud.
- Você já implantou uma função de 2ª geração. Por exemplo, siga o guia de início rápido para implantar uma função do Cloud Functions de segunda geração.
Ativar o Cloud Shell
- No Console do Cloud, clique em Ativar o Cloud Shell
.
Se esta for a primeira vez que você inicia o Cloud Shell, uma tela intermediária vai aparecer com a descrição dele. Se isso acontecer, clique em Continuar.
Leva apenas alguns instantes para provisionar e se conectar ao Cloud Shell.
Essa máquina virtual contém todas as ferramentas de desenvolvimento necessárias. Ela oferece um diretório principal persistente de 5 GB, além de ser executada no Google Cloud. Isso aprimora o desempenho e a autenticação da rede. Neste codelab, quase todo o trabalho pode ser feito com um navegador.
Depois de se conectar ao Cloud Shell, você vai ver que sua conta já está autenticada e que o projeto está configurado com o ID do seu projeto.
- Execute o seguinte comando no Cloud Shell para confirmar se a conta está autenticada:
gcloud auth list
Resposta ao comando
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Execute o comando a seguir no Cloud Shell para confirmar se o comando gcloud sabe sobre seu projeto:
gcloud config list project
Resposta ao comando
[core] project = <PROJECT_ID>
Se o projeto não estiver configurado, configure-o usando este comando:
gcloud config set project <PROJECT_ID>
Resposta ao comando
Updated property [core/project].
3. Criar os serviços do Cloud Run
Configurar as variáveis de ambiente.
Você pode definir variáveis de ambiente que serão usadas ao longo deste codelab.
PROJECT_ID=<YOUR_PROJECT_ID> REGION=<YOUR_REGION, e.g. us-central1> FRONTEND=frontend-with-internet BACKEND=backend SUBNET_NAME=default
Criar o serviço de back-end do Cloud Run
Primeiro, crie um diretório para o código-fonte e use cd para acessar esse diretório.
mkdir -p egress-private-codelab/frontend-w-internet egress-private-codelab/backend && cd egress-private-codelab/backend
Em seguida, crie um arquivo `package.json` com o seguinte conteúdo:
{
"name": "backend-service",
"version": "1.0.0",
"description": "",
"scripts": {
"start": "node index.js"
},
"dependencies": {
"express": "^4.18.1"
}
}
Em seguida, crie um arquivo de origem index.js com o conteúdo abaixo. Esse arquivo contém o ponto de entrada do serviço e a lógica principal do app.
const express = require('express');
const app = express();
app.use(express.urlencoded({ extended: true }));
app.get('/', function (req, res) {
res.send("hello world");
});
const port = parseInt(process.env.PORT) || 8080;
app.listen(port, () => {
console.log(`helloworld: listening on port ${port}`);
});
Por fim, implante o serviço do Cloud Run executando o seguinte comando.
gcloud run deploy $BACKEND --source . --allow-unauthenticated --region $REGION
Criar o serviço de front-end do Cloud Run
Navegue até o diretório do front-end.
cd ../frontend-w-internet
Em seguida, crie um arquivo package.json com o seguinte conteúdo:
{
"name": "frontend",
"version": "1.0.0",
"description": "",
"scripts": {
"start": "node index.js"
},
"keywords": [],
"author": "",
"license": "ISC",
"dependencies": {
"axios": "^1.6.6",
"express": "^4.18.2",
"htmx.org": "^1.9.10"
}
}
Em seguida, crie um arquivo de origem index.js com o conteúdo abaixo. Esse arquivo contém o ponto de entrada do serviço e a lógica principal do app.
const express = require("express");
const app = express();
const port = 8080;
const path = require('path');
const axios = require('axios');
// serve static content (index.html) using
// built-in middleware function in Express
app.use(express.static('public'));
app.use(express.urlencoded({ extended: true }));
// this endpoint receives a URL in the post body
// and then makes a get request to that URL
// results are sent back to the caller
app.post('/callService', async (req, res) => {
const url = req.body.url;
let message = "";
try {
console.log("url: ", url);
const response = await axios.get(url);
message = response.data;
} catch (error) {
message = error.message;
console.error(error.message);
}
res.send(`
${message}
<p>
</p>
`);
});
app.listen(port, () => {
console.log(`Example app listening on port ${port}`);
});
Criar um diretório público para o arquivo index.html
mkdir public touch public/index.html
E atualize o index.html para conter o seguinte:
<html>
<script
src="https://unpkg.com/htmx.org@1.9.10"
integrity="sha384-D1Kt99CQMDuVetoL1lrYwg5t+9QdHe7NLX/SoJYkXDFfX37iInKRy5xLSi8nO7UC"
crossorigin="anonymous"
></script>
<body>
<div style="margin-top: 100px; margin-left: 100px">
<h1>I'm the Request Tester service on the Internet</h1>
<form hx-trigger="submit" hx-post="/callService" hx-target="#zen">
<label for="url"> URL:</label>
<input
style="width: 308px"
type="text"
id="url"
name="url"
placeholder="The backend service URL"
required
/>
<button hx-indicator="#loading" type="submit">Submit</button>
<p></p>
<span class="htmx-indicator" id="loading"> Loading... </span>
<div id="zen" style="white-space: pre-wrap"></div>
<p></p>
</form>
</div>
</body>
</html>
Por fim, implante o serviço do Cloud Run executando o seguinte comando.
gcloud run deploy $FRONTEND --source . --allow-unauthenticated --region $REGION
Chamar o serviço de back-end
Nesta seção, você vai verificar se implantou dois serviços do Cloud Run.
Abra o URL do serviço de front-end no navegador da Web, por exemplo, https://frontend-your-hash-uc.a.run.app/.
Na caixa de texto, insira o URL do serviço de back-end. Observe que esta solicitação é encaminhada da instância do Cloud Run de front-end para o serviço do Cloud Run de back-end, e não do seu navegador.
Você vai ver "hello world"
4. Definir o serviço de back-end somente para entrada interna
Execute o seguinte comando gcloud para incorporar um serviço do Cloud Run à sua rede particular.
gcloud run services update $BACKEND --ingress internal --region $REGION
Se você tentasse chamar o serviço de back-end do serviço de front-end, receberia um erro 404. A conexão de saída (ou saída) do serviço de front-end do Cloud Run vai primeiro para a Internet. Assim, o Google Cloud não sabe a origem da solicitação.
5. Configurar o serviço de front-end para acessar a VPC
Nesta seção, você vai configurar o serviço de front-end do Cloud Run para se comunicar com o serviço de back-end por uma VPC.
Para isso, adicione a saída VPC direta ao serviço de front-end do Cloud Run para garantir que ele possa alcançar endereços IP internos na rede VPC. Em seguida, você vai configurar a saída para que apenas solicitações de IPs particulares sejam roteadas para a VPC. Essa configuração permite que o front-end ainda alcance a Internet pública. Saiba mais na documentação sobre receber solicitações de outros serviços do Cloud Run.
Configurar a saída direta da VPC
Primeiro, execute este comando para usar a saída direta de VPC no serviço de front-end:
gcloud beta run services update $FRONTEND \ --network=$SUBNET_NAME \ --subnet=$SUBNET_NAME \ --vpc-egress=private-ranges-only \ --region=$REGION
Agora você pode confirmar se o serviço de front-end tem acesso à VPC:
gcloud beta run services describe $FRONTEND \ --region=$REGION
Você vai ver uma saída semelhante a
VPC access:
Network: default
Subnet: default
Egress: private-ranges-only
Ativar o Acesso privado do Google
Em seguida, ative o Acesso privado do Google na sub-rede executando o seguinte comando:
gcloud compute networks subnets update $SUBNET_NAME \ --region=$REGION \ --enable-private-ip-google-access
Para verificar se o Acesso privado do Google foi ativado, execute este comando:
gcloud compute networks subnets describe $SUBNET_NAME \ --region=$REGION \ --format="get(privateIpGoogleAccess)"
Criar uma zona de DNS do Cloud DNS para URLs run.app
Por fim, crie uma zona de DNS do Cloud DNS para URLs run.app para que o Google Cloud possa tratá-los como endereços IP internos.
Em uma etapa anterior, quando você configurou a saída direta da VPC para intervalos particulares. Isso significa que as conexões de saída do seu serviço de front-end só vão para a rede VPC se o destino for um IP interno. No entanto, o serviço de back-end usa um URL run.app que é resolvido para um IP público.
Nesta etapa, você vai criar uma zona de DNS do Cloud DNS para que os URLs run.app sejam resolvidos para os intervalos de endereços IP private.googleapis.com, que são reconhecidos como endereços IP internos. Agora, todas as solicitações para esses intervalos serão roteadas pela sua rede VPC.
Para fazer isso, acesse: https://cloud.google.com/run/docs/securing/private-networking#from-other-services
# do not include the https:// in your DNS Name # for example: backend-<hash>-uc.a.run.app DNS_NAME=<your backend service URL without the https://> gcloud dns --project=$PROJECT_ID managed-zones create codelab-backend-service \ --description="" \ --dns-name="a.run.app." \ --visibility="private" \ --networks=$SUBNET_NAME gcloud dns --project=$PROJECT_ID record-sets create $DNS_NAME. \ --zone="codelab-backend-service" \ --type="A" \ --ttl="60" \ --rrdatas="199.36.153.8,199.36.153.9,199.36.153.10,199.36.153.11"
Agora, quando você tentar acessar o serviço de back-end do seu site, a mensagem "hello world" vai aparecer.
E quando você tentar acessar a Internet usando https://curlmyip.org/, seu endereço IP vai aparecer.
6. Solução de problemas
Confira algumas mensagens de erro que podem aparecer se as configurações não forem feitas corretamente.
- Se você receber um erro
getaddrinfo ENOTFOUND backend-your-hash-uc.a.run.app, verifique se não adicionou "https://" ao registro A de DNS. - Se você receber um erro 404 ao tentar acessar o back-end depois de configurar a zona, aguarde o vencimento do cache no registro global run.app (por exemplo, 6 horas) ou crie uma nova revisão (limpando o cache) executando o seguinte comando:
gcloud beta run services update $FRONTEND --network=$SUBNET_NAME --subnet=$SUBNET_NAME --vpc-egress=private-ranges-only --region=$REGION
7. Parabéns!
Parabéns por concluir o codelab!
Recomendamos consultar a documentação sobre Rede particular no Cloud Run.
O que vimos
- Como permitir apenas o tráfego de uma VPC para seu serviço do Cloud Run
- Como configurar a saída em um serviço do Cloud Run (por exemplo, front-end) para se comunicar com um serviço do Cloud Run somente de entrada interna (por exemplo, back-end), mantendo o acesso à Internet pública para o serviço de front-end.
8. Limpar
Para evitar cobranças acidentais (por exemplo, se esse serviço do Cloud Run for invocado mais vezes do que sua alocação mensal de invocações do Cloud Run no nível sem custo financeiro), exclua o serviço do Cloud Run ou o projeto criado na etapa 2.
Para excluir os serviços do Cloud Run, acesse o console do Cloud Run em https://console.cloud.google.com/functions/ e exclua os serviços $FRONTEND e $BACKEND criados neste codelab.
Se você quiser excluir todo o projeto, acesse https://console.cloud.google.com/cloud-resource-manager, selecione o projeto criado na Etapa 2 e escolha "Excluir". Se você excluir o projeto, vai precisar mudar de projeto no SDK Cloud. Para conferir a lista de todos os projetos disponíveis, execute gcloud projects list.