Visão geral

Neste laboratório, você vai criar um cluster particular, adicionar uma rede autorizada para acesso da API e definir uma política de rede para a segurança do pod.

Observação: neste laboratório, o modo GKE Standard será usado, e você vai conhecer as políticas de rede do cluster que são ativadas por padrão no Autopilot do GKE.

Objetivos

Neste laboratório, você vai aprender a:

• criar e testar um cluster particular;
• configurar um cluster para acesso autorizado ao plano de controle de rede;
• configurar uma política de rede do cluster.

Configuração e requisitos

Para cada laboratório, você recebe um novo projeto do Google Cloud e um conjunto de recursos por um determinado período sem custo financeiro.

1. Clique no botão Começar o laboratório. Se for preciso pagar, você verá um pop-up para selecionar a forma de pagamento. No painel Detalhes do laboratório à esquerda, você vai encontrar o seguinte:

   • O botão Abrir console do Google Cloud
   • O tempo restante
   • As credenciais temporárias que você vai usar neste laboratório
   • Outras informações, se forem necessárias

2. Se você estiver usando o navegador Chrome, clique em Abrir console do Google Cloud ou clique com o botão direito do mouse e selecione Abrir link em uma janela anônima.

   O laboratório ativa os recursos e depois abre a página Fazer login em outra guia.

   Dica: coloque as guias em janelas separadas lado a lado.

   Observação: se aparecer a caixa de diálogo Escolher uma conta, clique em Usar outra conta.

3. Se necessário, copie o Nome de usuário abaixo e cole na caixa de diálogo Fazer login.

   {{{user_0.username | "Nome de usuário"}}}

   Você também encontra o Nome de usuário no painel Detalhes do laboratório.

4. Clique em Seguinte.

5. Copie a Senha abaixo e cole na caixa de diálogo de boas-vindas.

   {{{user_0.password | "Senha"}}}

   Você também encontra a Senha no painel Detalhes do laboratório.

6. Clique em Seguinte.

   Importante: você precisa usar as credenciais fornecidas no laboratório, e não as da sua conta do Google Cloud. Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais.

7. Acesse as próximas páginas:

   • Aceite os Termos e Condições.
   • Não adicione opções de recuperação nem autenticação de dois fatores (porque essa é uma conta temporária).
   • Não se inscreva em testes gratuitos.

Depois de alguns instantes, o console do Google Cloud será aberto nesta guia.

Observação: para acessar uma lista de produtos e serviços do Google Cloud, clique no Menu de navegação no canto superior esquerdo ou digite o nome do serviço ou produto no campo Pesquisar.

Depois que você concluir as etapas iniciais de login, o painel do projeto será exibido.

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:

gcloud auth list

Saída:

Credentialed accounts: - @.com (active)

Exemplo de saída:

Credentialed accounts: - google1623327_student@qwiklabs.net

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

gcloud config list project

Saída:

[core] project =

Exemplo de saída:

[core] project = qwiklabs-gcp-44776a13dea667a6 Observação: a documentação completa da gcloud está disponível no guia com informações gerais sobre a gcloud CLI .

Tarefa 1: crie um cluster particular

Nesta tarefa, você vai criar um cluster particular, analisar os níveis de privacidade e fazer uma comparação entre o cluster particular e o cluster original.

Em um cluster particular, os nós têm apenas endereços IP RFC 1918 internos. Isso garante que as cargas de trabalho fiquem isoladas da Internet pública. Os nós em um cluster não particular têm endereços IP externos, o que pode permitir a entrada e saída de tráfego da Internet.

Configure um cluster particular

1. No Menu de navegação (), clique em Kubernetes Engine > Clusters.
2. Clique em Criar e selecione MUDAR PARA O CLUSTER PADRÃO.
3. Dê o nome private-cluster ao cluster.
4. Selecione como a zona.
5. No painel à esquerda, selecione default-pool em Pools de nós.
6. Em Número de nós, digite 2.

7. No painel à esquerda, selecione Rede em Cluster.
8. Confira se a opção Ativar redes autorizadas não está selecionada.
9. Marque a caixa de seleção para Substituir a sub-rede padrão de endpoint particular do plano de controle.
10. Em Sub-rede de endpoint particular, selecione padrão.

11. Marque a caixa de seleção para Ativar nós particulares.

Observação: o Google Cloud usa o peering para conectar a VPC do cluster à rede VPC padrão.

Para ver essa opção, você precisará rolar para baixo.

Essa configuração define o intervalo de endereços que podem acessar o cluster externamente. Com essa opção selecionada, só é possível acessar a kubectl pela rede do Google Cloud. Neste laboratório, você vai acessar a kubectl apenas pela rede do Google Cloud, mas precisará mudar essa configuração depois.

12. Clique em Criar.

Nota: espere alguns minutos até que a implantação do cluster seja concluída.

Inspecione seu cluster

• No Cloud Shell, insira o comando a seguir para analisar os detalhes do novo cluster:

gcloud container clusters describe private-cluster --zone {{{project_0.default_zone|ZONE}}}

Os valores a seguir aparecem apenas abaixo do cluster particular:

• privateEndpoint, um endereço IP interno. Os nós usam esse endereço IP interno para se comunicar com o plano de controle do cluster.
• publicEndpoint, um endereço IP externo. Serviços e administradores externos podem usar o endereço IP externo para se comunicar com o plano de controle do cluster.

Há várias opções e níveis de bloqueio do cluster:

• Todo o cluster pode ter acesso externo.
• Todo o cluster pode ser particular.
• Os nós podem ser particulares com o plano de controle do cluster público, e é possível limitar quais redes externas estão autorizadas a acessar o plano.

Sem os endereços IP públicos, o código em execução nos nós não pode acessar a Internet pública, a menos que você configure um gateway NAT, como o Cloud NAT.

É possível usar clusters particulares para disponibilizar serviços, como APIs internas, que só podem ser acessados por recursos que estão dentro da rede. Por exemplo, os recursos podem ser ferramentas privadas usadas exclusivamente pela sua empresa. Ou podem ser serviços de back-end acessados pelos serviços de front-end, e talvez somente esses serviços de front-end sejam acessados diretamente por clientes ou usuários externos. Nesses casos, os clusters particulares são uma boa maneira de reduzir a superfície de ataque do aplicativo.

Clique em Verificar meu progresso para conferir o objetivo. Crie um cluster privado

Tarefa 2: adicione uma rede autorizada para acesso ao plano de controle do cluster

Depois de criar o cluster, talvez você precise executar comandos nele fora do Google Cloud. Por exemplo, é possível definir que apenas a rede corporativa enviará comandos para o plano de controle do cluster. Você não especificou a rede autorizada quando criou o cluster.

Nesta tarefa, você vai autorizar uma rede para acessar o plano de controle do cluster.

Observação: na tarefa, você vai tornar a API do plano de controle do Kubernetes acessível a um intervalo específico de endereços de rede. Em casos de uso reais do GKE, essa conexão seria usada pela equipe de TI e por processos automatizados, não por usuários finais.

1. No Menu de navegação do console do Google Cloud (), selecione Kubernetes Engine > Clusters.
2. Clique em private-cluster para abrir a página de detalhes dos clusters.
3. Na guia Detalhes, na seção Rede do plano de controle, clique em Editar().
4. Selecione Ativar redes autorizadas.
5. Clique em Adicionar uma rede autorizada.
6. Em Nome, digite o nome da rede, use Corporate.
7. Em Rede, digite um intervalo CIDR para conceder a ele permissão de acesso ao plano de controle do cluster. Por exemplo, você pode usar 192.168.1.0/24.
8. Clique em Concluído.
9. Verifique se os seguintes parâmetros estão ativados:
   • Acessar usando o endereço IP externo do plano de controle
   • Acessar usando o endereço IP interno do plano de controle de qualquer região
   • Aplicar redes autorizadas no endpoint interno do plano de controle
   • Adicionar endereços IP externos do Google Cloud a redes autorizadas

Se for necessário, é possível adicionar várias redes, mas sem ultrapassar 50 intervalos CIDR.

Observação: fora do ambiente deste laboratório, um exemplo prático seria incluir na lista de permissões apenas o endereço público externo do firewall corporativo. Por exemplo, se o endereço IP do firewall corporativo fosse 8.8.8.14, você poderia incluir 8.8.8.14/32 na lista de permissões de acesso.

9. Clique em Salvar alterações na parte de baixo do menu.

Clique em Verificar meu progresso para conferir o objetivo. Adicione uma rede autorizada para acesso ao plano de controle do cluster

Tarefa 3: crie uma política de rede do cluster

Nesta tarefa, você criará uma política de rede do cluster para restringir a comunicação entre os pods. É importante ter uma zona de confiança zero para impedir ataques laterais dentro do cluster quando um invasor comprometer um dos pods.

Crie um cluster do GKE

1. No Cloud Shell, digite o comando a seguir para definir a variável de ambiente da zona e o nome do cluster:

export my_zone={{{project_0.default_zone|ZONE}}} export my_cluster=standard-cluster-1

2. Configure o preenchimento com tabulação da kubectl no Cloud Shell:

source <(kubectl completion bash)

3. No Cloud Shell, digite o comando abaixo para criar um cluster do Kubernetes. Observe que esse comando adiciona a flag --enable-network-policy aos parâmetros usados nos laboratórios anteriores. Essa flag permite que o novo cluster use as políticas de rede de clusters.

gcloud container clusters create $my_cluster --num-nodes 3 --enable-ip-alias --zone $my_zone --enable-network-policy

4. No Cloud Shell, use o comando a seguir para configurar o acesso da ferramenta de linha de comando kubectl ao cluster:

gcloud container clusters get-credentials $my_cluster --zone $my_zone

5. Execute um aplicativo simples de servidor da Web com o rótulo app=hello e exponha o app internamente no cluster:

kubectl run hello-web --labels app=hello \ --image=gcr.io/google-samples/hello-app:1.0 --port 8080 --expose

Restringir o tráfego de entrada nos pods

Vamos criar um modelo de arquivo de manifesto do NetworkPolicy chamado hello-allow-from-foo.yaml. Esse arquivo de manifesto define uma política de entrada que permite o acesso aos pods com o rótulo app: hello pelos pods app: foo.

1. Crie e abra um arquivo chamado hello-allow-from-foo.yaml com o nano usando o seguinte comando:

nano hello-allow-from-foo.yaml

2. Quando o nano estiver aberto, cole o seguinte no arquivo hello-allow-from-foo.yaml:

kind: NetworkPolicy apiVersion: networking.k8s.io/v1 metadata: name: hello-allow-from-foo spec: policyTypes: - Ingress podSelector: matchLabels: app: hello ingress: - from: - podSelector: matchLabels: app: foo

3. Pressione Ctrl+O e, em seguida, Enter para salvar o arquivo editado.

4. Pressione Ctrl+X para sair do editor de texto nano.

5. Crie uma política de entrada:

kubectl apply -f hello-allow-from-foo.yaml

6. Verifique se a política foi criada:

kubectl get networkpolicy

Saída:

NAME POD-SELECTOR AGE hello-allow-from-foo app=hello 7s

Valide a política de entrada

1. Execute um pod temporário chamado test-1 com o rótulo app=foo e receba um shell no pod:

kubectl run test-1 --labels app=foo --image=alpine --restart=Never --rm --stdin --tty Observação: é importante observar as opções de kubectl usadas aqui em conjunto com o comando "run".

--stdin (como alternativa, -i) cria uma sessão interativa anexada ao STDIN no contêiner.

--tty (como alternativa, -t) aloca um TTY para cada contêiner no pod.

--rm instrui o Kubernetes a tratar isso como um pod temporário que será removido assim que terminar a tarefa de inicialização. Como esta é uma sessão interativa, ele será removido assim que o usuário sair da sessão.

--label (como alternativa, -l) adiciona um conjunto de rótulos ao pod.

--restart define a política de reinicialização do pod.

2. Faça uma solicitação ao endpoint hello-web:8080 para verificar se o tráfego de entrada é permitido:

wget -qO- --timeout=2 http://hello-web:8080

Saída:

If you don't see a command prompt, try pressing enter. / # wget -qO- --timeout=2 http://hello-web:8080 Hello, world! Version: 1.0.0 Hostname: hello-web-8b44b849-k96lh / #

3. Digite exit e pressione ENTER para sair do shell.

4. Agora, você executará um pod diferente usando o mesmo nome do pod, mas com um rótulo, app=other, que não corresponde ao podSelector na política de rede ativa. Esse pod não pode acessar o aplicativo hello-web.

kubectl run test-1 --labels app=other --image=alpine --restart=Never --rm --stdin --tty

5. Faça uma solicitação ao endpoint hello-web:8080 para verificar se o tráfego de entrada não é permitido:

wget -qO- --timeout=2 http://hello-web:8080

A solicitação expira.

Saída:

If you don't see a command prompt, try pressing enter. / # wget -qO- --timeout=2 http://hello-web:8080 wget: download timed out / #

6. Digite exit e pressione ENTER para sair do shell.

Restrinja o tráfego de saída dos pods

Assim como você faz com o tráfego de entrada, é possível restringir o tráfego de saída. Porém, para consultar nomes do host internos (como hello-web) ou nomes do host externos (como www.example.com), permita a resolução de DNS em suas políticas de rede de saída. O tráfego DNS ocorre na porta 53 usando os protocolos TCP e UDP.

Vamos criar um arquivo de manifesto do NetworkPolicy foo-allow-to-hello.yaml. Esse arquivo define uma política que permite que pods com o rótulo app: foo se comuniquem com pods rotulados como app: hello em qualquer porta, e que os pods rotulados como app: foo se comuniquem com qualquer computador na porta UDP 53, que é usada para resolução de DNS. Sem a porta DNS aberta, não será possível resolver os nomes do host.

1. Crie e abra um arquivo chamado foo-allow-to-hello.yaml com o nano usando o seguinte comando:

nano foo-allow-to-hello.yaml

2. Quando o nano estiver aberto, cole o seguinte no arquivo foo-allow-to-hello.yaml:

kind: NetworkPolicy apiVersion: networking.k8s.io/v1 metadata: name: foo-allow-to-hello spec: policyTypes: - Egress podSelector: matchLabels: app: foo egress: - to: - podSelector: matchLabels: app: hello - to: ports: - protocol: UDP port: 53

3. Pressione Ctrl+O e, em seguida, Enter para salvar o arquivo editado.

4. Pressione Ctrl+X para sair do editor de texto nano.

5. Crie uma política de saída:

kubectl apply -f foo-allow-to-hello.yaml

6. Verifique se a política foi criada:

kubectl get networkpolicy

Saída:

NAME POD-SELECTOR AGE foo-allow-to-hello app=foo 7s hello-allow-from-foo app=hello 5m

Valide a política de saída

1. Implante um novo aplicativo da Web chamado hello-web-2 e exponha o app internamente no cluster:

kubectl run hello-web-2 --labels app=hello-2 \ --image=gcr.io/google-samples/hello-app:1.0 --port 8080 --expose

2. Execute um pod temporário com o rótulo app=foo e receba um comando de shell dentro do contêiner:

kubectl run test-3 --labels app=foo --image=alpine --restart=Never --rm --stdin --tty

3. Confirme se o pod consegue estabelecer conexões com hello-web:8080:

wget -qO- --timeout=2 http://hello-web:8080

Saída:

If you don't see a command prompt, try pressing enter. / # wget -qO- --timeout=2 http://hello-web:8080 Hello, world! Version: 1.0.0 Hostname: hello-web / #

4. Confirme se o pod não consegue estabelecer conexões com hello-web-2:8080:

wget -qO- --timeout=2 http://hello-web-2:8080

Ocorrerá uma falha porque nenhuma das políticas de rede que você definiu permite o tráfego para pods com o rótulo app: hello-2.

5. Confirme se o pod não consegue estabelecer conexões com sites externos, como www.example.com:

wget -qO- --timeout=2 http://www.example.com

Ocorrerá uma falha porque as políticas de rede não permitem tráfego HTTP externo (porta TCP 80).

6. Digite exit e pressione ENTER para sair do shell.

Clique em Verificar meu progresso para conferir o objetivo. Execute aplicativos de servidor da Web

Finalize o laboratório

Clique em Terminar o laboratório após a conclusão. O Google Cloud Ensina remove os recursos usados e limpa a conta por você.

Você vai poder avaliar sua experiência no laboratório. Basta selecionar o número de estrelas, digitar um comentário e clicar em Enviar.

O número de estrelas indica o seguinte:

• 1 estrela = muito insatisfeito
• 2 estrelas = insatisfeito
• 3 estrelas = neutro
• 4 estrelas = satisfeito
• 5 estrelas = muito satisfeito

Feche a caixa de diálogo se não quiser enviar feedback.

Para enviar seu feedback, fazer sugestões ou correções, use a guia Suporte.

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