Tarefa 2: provisionar o Jenkins

Crie um cluster do Kubernetes e autorize o Jenkins a acessar os serviços do Google Cloud e o Google Artifact Registry.

Criar um cluster do Kubernetes

1. Agora, execute o comando a seguir para provisionar um cluster do Kubernetes:

gcloud container clusters create jenkins-cd \ --num-nodes 2 \ --machine-type e2-standard-2 \ --scopes "https://www.googleapis.com/auth/source.read_write,cloud-platform"

Essa etapa pode levar alguns minutos para ser concluída. Os escopos extras permitem que o Jenkins acesse os serviços do Google Cloud e o Google Artifact Registry.

Criar um cluster do Kubernetes

1. Agora execute o seguinte comando para provisionar um cluster do Kubernetes:

gcloud container clusters create jenkins-cd \ --num-nodes 2 \ --machine-type e2-standard-2 \ --scopes "https://www.googleapis.com/auth/source.read_write,cloud-platform"

Essa etapa pode demorar vários minutos para ser concluída. Os escopos extras permitem que o Jenkins acesse os serviços do Google Cloud e o Google Artifact Registry.

Clique em Verificar meu progresso para conferir a tarefa realizada. Se o cluster do Kubernetes tiver sido criado corretamente, você vai receber uma pontuação de avaliação.

Criar um cluster do Kubernetes (zona: )

2. Antes de continuar, execute o seguinte comando para confirmar se o cluster está ativo:

gcloud container clusters list

Credenciar o cluster

1. Receba as credenciais do seu cluster.

gcloud container clusters get-credentials jenkins-cd

2. O Kubernetes Engine usa essas credenciais para acessar seu cluster recém-provisionado. Confirme se você consegue se conectar a ele executando o seguinte comando:

kubectl cluster-info

Tarefa 3: configurar o Helm

O Helm é um gerenciador de pacotes que facilita a configuração e a implantação de aplicativos do Kubernetes. Depois de instalar o Jenkins, configure seu pipeline de CI/CD.

Nesta tarefa, você vai usar o Helm para instalar o Jenkins no repositório de gráficos.

1. Adicione o repositório de gráfico estável do Helm:

helm repo add jenkins https://charts.jenkins.io

2. Use o seguinte comando para confirmar se o repositório está atualizado:

helm repo update

Tarefa 4: instalar e configurar o Jenkins

Ao instalar o Jenkins, é possível usar um arquivo values como modelo para fornecer os valores necessários para a configuração.

Use o arquivo values personalizado para configurar automaticamente o Kubernetes Cloud e adicione estes plug-ins necessários:

• Kubernetes:latest
• Workflow-multibranch:latest
• Git:latest
• Configuration-as-code:latest
• Google-oauth-plugin:latest
• Google-source-plugin:latest
• Google-storage-plugin:latest

Dessa forma, o Jenkins se conecta ao cluster e ao projeto do Google Cloud.

1. Use a CLI do Helm para implantar o gráfico com suas configurações:

helm install cd jenkins/jenkins -f jenkins/values.yaml --wait

Talvez leve alguns minutos para que o comando seja concluído.

Clique em Verificar meu progresso para conferir a tarefa realizada. Se o gráfico do Jenkins tiver sido configurado corretamente, será exibida uma pontuação de avaliação.

Configurar e instalar o Jenkins

2. Depois de executar o comando, verifique se o estado do pod do Jenkins está definido como Running e o do contêiner como "READY":

kubectl get pods

Exemplo de resposta:

NAME READY STATUS RESTARTS AGE cd-jenkins-7c786475dd-vbhg4 2/2 Running 0 1m

3. Configure a conta de serviço do Jenkins para fazer a implantação no cluster:

kubectl create clusterrolebinding jenkins-deploy --clusterrole=cluster-admin --serviceaccount=default:cd-jenkins

Você vai receber esta resposta:

clusterrolebinding.rbac.authorization.k8s.io/jenkins-deploy created

4. Execute o seguinte comando para configurar o encaminhamento de portas na interface do Jenkins no Cloud Shell:

export POD_NAME=$(kubectl get pods --namespace default -l "app.kubernetes.io/component=jenkins-master" -l "app.kubernetes.io/instance=cd" -o jsonpath="{.items[0].metadata.name}") kubectl port-forward $POD_NAME 8080:8080 >> /dev/null &

5. Agora verifique se o serviço do Jenkins foi criado corretamente:

kubectl get svc

Exemplo de resposta:

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE cd-jenkins 10.35.249.67 8080/TCP 3h cd-jenkins-agent 10.35.248.1 50000/TCP 3h kubernetes 10.35.240.1 443/TCP 9h

Você está usando o plug-in do Kubernetes para iniciar automaticamente os nós do builder, conforme necessário, quando for solicitado pelo mestre do Jenkins. Ao final do processo, os nós do builder são automaticamente desativados, e os recursos são adicionados outra vez ao pool de recursos do cluster.

Esse serviço expõe as portas 8080 e 50000 dos pods que correspondem ao seletor. Com isso, a interface da web do Jenkins e as portas de registro do builder/agente são expostas no cluster do Kubernetes. Além disso, o serviço jenkins-ui é exposto usando um ClusterIP para evitar o acesso a ele de fora do cluster.

Tarefa 5: conectar ao Jenkins

Recupere a senha de admin e faça login na interface do Jenkins.

1. O gráfico do Jenkins cria automaticamente uma senha de admin para você. Para consultar a senha, execute este comando:

printf $(kubectl get secret cd-jenkins -o jsonpath="{.data.jenkins-admin-password}" | base64 --decode);echo

2. Para acessar a interface do usuário do Jenkins, na barra de ação do Cloud Shell, clique em Visualização na Web () Visualizar na porta 8080:

3. Se for necessário, faça login com o nome de usuário admin e a senha gerada automaticamente.

A configuração do Jenkins no seu cluster do Kubernetes está pronta. O Jenkins vai gerenciar seus pipelines automatizados de CI/CD nas próximas seções.

Tarefa 6: entender o aplicativo

Nesta tarefa, você vai implantar o aplicativo de exemplo gceme no pipeline de implantação contínua. O aplicativo, escrito na linguagem Go, está no diretório sample-app do repositório. Quando você executa o binário gceme em uma instância do Compute Engine, o app exibe os metadados da instância em um card de informação.

O aplicativo aceita dois modos de operação para simular um microsserviço.

• No modo de back-end: o gceme detecta a atividade da porta 8080 e retorna metadados da instância do Compute Engine no formato JSON.
• No modo de front-end: o gceme consulta o serviço de back-end e renderiza o JSON resultante na interface do usuário.

Tarefa 7: implantar o aplicativo

Implante o aplicativo em dois ambientes diferentes:

• Produção: é o site ativo que os usuários acessam.
• Canário: é um site de capacidade menor que só recebe uma porcentagem do tráfego do usuário. Use esse ambiente para validar seu software com o tráfego ativo antes de lançá-lo para todos os usuários.

1. No Google Cloud Shell, navegue para o diretório de aplicativos de amostra:

cd sample-app

2. Crie o namespace do Kubernetes para isolar logicamente a implantação:

kubectl create ns production

3. Use os comandos kubectl apply para criar as implantações das versões de produção e canário, além dos serviços:

kubectl apply -f k8s/production -n production kubectl apply -f k8s/canary -n production kubectl apply -f k8s/services -n production

Clique em Verificar meu progresso para conferir a tarefa realizada. Se as implantações tiverem sido criadas corretamente, vai aparecer uma pontuação de avaliação.

Criar as implantações de produção e canário

Por padrão, somente uma réplica do front-end é implantada. Use o comando kubectl scale para garantir o mínimo de quatro réplicas em execução o tempo todo.

4. Escalone verticalmente os front-ends do ambiente de produção executando o seguinte comando:

kubectl scale deployment gceme-frontend-production -n production --replicas 4

5. Agora confirme que você tem cinco pods em execução para o front-end, quatro para o tráfego de produção e um para as versões canário. As mudanças na versão canário vão afetar somente um a cada cinco usuários (20%):

kubectl get pods -n production -l app=gceme -l role=frontend

6. Além disso, confirme que você tem dois pods para o back-end, um para a produção e um para a versão canário:

kubectl get pods -n production -l app=gceme -l role=backend

7. Recupere o IP externo dos serviços de produção:

kubectl get service gceme-frontend -n production Observação: o endereço IP externo do balanceador de carga talvez leve alguns minutos para aparecer.

Exemplo de resposta:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE gceme-frontend LoadBalancer 10.79.241.131 104.196.110.46 80/TCP 5h

Cole o IP externo no navegador para exibir o card de informação. Uma página semelhante a esta vai aparecer:

8. Agora armazene o IP do balanceador de carga do serviço de front-end em uma variável de ambiente para usar mais tarde:

export FRONTEND_SERVICE_IP=$(kubectl get -o jsonpath="{.status.loadBalancer.ingress[0].ip}" --namespace=production services gceme-frontend)

9. Para confirmar que os dois serviços estão funcionando, abra o endereço IP externo do front-end no navegador.

10. Execute o seguinte comando para verificar a resposta da versão do serviço (que deve ser 1.0.0):

curl http://$FRONTEND_SERVICE_IP/version

Pronto. Você implantou o aplicativo de amostra. Em seguida, configure um pipeline para implantar as alterações de maneira contínua e confiável.

Tarefa 8: criar o pipeline do Jenkins

Nesta tarefa, você configurará um repositório Git no seu servidor Git dedicado e criará o pipeline do Jenkins:

• Enviar o código-fonte do aplicativo de exemplo para o servidor Git
• Adicionar as credenciais da conta de serviço ao Jenkins
• Configurar o Jenkins Cloud para Kubernetes
• Criar o job de pipeline multiramificação do Jenkins

Enviar o código-fonte do aplicativo de exemplo para o servidor Git

1. No Cloud Shell, recupere o endereço IP externo do servidor Git:

export GIT_SERVER_IP=$(gcloud compute instances describe git-server --zone={{{project_0.default_zone}}} --format='get(networkInterfaces[0].accessConfigs[0].natIP)') echo "Git Server IP: ${GIT_SERVER_IP}"

2. Inicialize o diretório sample-app como um repositório Git:

cd ~/continuous-deployment-on-kubernetes/sample-app git init git config --global user.email "student@qwiklabs.net" git config --global user.name "Student" git branch -m master

3. Adicione o repositório remoto apontando para o seu servidor Git auto-hospedado:

git remote add origin http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/sample-app.git

4. Adicione, confirme e envie os arquivos para a ramificação master:

git add . git commit -m "Initial commit" git push -u origin master

Adicionar as credenciais da conta de serviço

Configure suas credenciais para permitir que o Jenkins acesse o cluster e implante recursos.

1. Na interface de usuário do Jenkins, clique em Manage Jenkins no painel esquerdo e em Credentials (em Security).

2. Em Stores scoped to Jenkins, clique em System.

3. Clique em Global credentials (unrestricted).

4. Clique em Add Credentials.

5. Em Kind, selecione Google Service Account from metadata e clique em Next.

6. No campo ID, insira o ID do seu projeto () e clique em Create.

Observação: o ID do projeto pode ser encontrado no painel DETALHES DA CONEXÃO do laboratório.

As credenciais globais foram adicionadas.

Configurar o Jenkins Cloud para Kubernetes

1. Na interface de usuário do Jenkins, selecione Manage Jenkins > Clouds (ou System > Clouds).
2. Clique em New cloud.
3. No campo Cloud name, digite kubernetes, selecione Kubernetes para Type e clique em Create.
4. No campo Jenkins URL, insira http://cd-jenkins:8080.
5. No campo Jenkins tunnel, insira cd-jenkins-agent:50000.
6. Clique em Save.

Criar o job do Jenkins

Acesse a interface de usuário do Jenkins e siga estas etapas para configurar um job de pipeline multiramificação:

1. Clique em Jenkins > New Item no painel esquerdo.

2. Insira o nome do item sample-app, escolha a opção Multibranch Pipeline e clique em OK.

3. Na página seguinte, na seção Branch Sources, selecione Git no menu suspenso Add source.

4. No campo Project Repository, insira o URL de clonagem do seu repositório:

http://{{{project_0.startup_script.git_server_ip}}}:3000/giteaadmin/sample-app.git Observação: se a variável não for preenchida automaticamente, você poderá inserir http://[GIT_SERVER_IP]:3000/giteaadmin/sample-app.git substituindo [GIT_SERVER_IP] pelo IP do seu servidor Git.

5. Em Credentials, mantenha a opção definida como - none -.

6. Na seção Scan Multibranch Pipeline Triggers, marque a caixa de seleção Periodically if not otherwise run e defina o valor de Interval como 1 minute.

7. Mantenha todas as outras opções nos valores padrão e clique em Save.

Depois de concluir essas etapas, um job chamado Branch indexing será executado. Esse metajob identifica as ramificações no seu repositório e garante que não ocorreram alterações nas ramificações existentes. Se você clicar em sample-app na navegação, o job master deverá ser exibido.

Observação: a primeira execução do job master pode falhar até que você faça algumas alterações no código na próxima etapa.

Você criou um pipeline do Jenkins com êxito. A seguir, você criará o ambiente de desenvolvimento para a integração contínua.

Tarefa 9: criar o ambiente de desenvolvimento

Uma ramificação de desenvolvimento é um conjunto de ambientes que os desenvolvedores usam para testar as alterações no código antes de enviá-las para integração ao site ativo. Esses ambientes são versões reduzidas do aplicativo, mas precisam ser implantados com os mesmos mecanismos do ambiente ativo.

Criar uma ramificação de desenvolvimento

Para criar um ambiente de desenvolvimento em uma ramificação de recursos, envie a ramificação por push ao servidor Git e deixe o Jenkins implantar o ambiente.

Observação: se você encontrar erros no Cloud Shell, pressione CTRL+C e execute o comando abaixo.

• Crie uma ramificação de desenvolvimento e envie-a por push ao servidor Git:

git checkout -b new-feature

Modificar a definição de pipeline

O Jenkinsfile que define o pipeline é escrito com a sintaxe do Groovy para pipelines do Jenkins (página em inglês). Com um Jenkinsfile, é possível expressar todo o pipeline de build em um único arquivo que coexiste com o código-fonte. Os pipelines aceitam recursos avançados, como o carregamento em paralelo, e exigem a aprovação manual do usuário.

Para que o pipeline funcione como esperado, é preciso modificar o Jenkinsfile para definir o ID do seu projeto.

1. Abra o Jenkinsfile no seu editor de terminal, por exemplo, vi:

vi Jenkinsfile

2. Inicie o editor:

i

3. Adicione o PROJECT_ID ao valor REPLACE_WITH_YOUR_PROJECT_ID. O PROJECT_ID é o ID do seu projeto que fica na seção CONNECTION DETAILS (Detalhes da conexão) do laboratório. Ele também pode ser localizado usando gcloud config get-value project.

4. Altere o valor da CLUSTER_ZONE para . É possível conseguir esse valor usando gcloud config get compute/zone.

PROJECT = "REPLACE_WITH_YOUR_PROJECT_ID" APP_NAME = "gceme" FE_SVC_NAME = "${APP_NAME}-frontend" CLUSTER = "jenkins-cd" CLUSTER_ZONE = "{{{project_0.default_zone}}}" IMAGE_TAG = "gcr.io/${PROJECT}/${APP_NAME}:${env.BRANCH_NAME}.${env.BUILD_NUMBER}" JENKINS_CRED = "${PROJECT}"

5. Salve o arquivo Jenkinsfile, pressione a tecla Esc (para usuários do vi) e use:

:wq

Modificar o site

Para demonstrar como alterar o aplicativo, mude a cor dos cards do gceme de azul para laranja.

1. Abra o html.go:

vi html.go

2. Inicie o editor:

i

3. Mude as duas instâncias de <div class="card blue"> com o seguinte código:

<div class="card orange">

4. Salve o arquivo html.go, pressione a tecla Esc e use:

:wq

5. Abra o main.go:

vi main.go

6. Inicie o editor:

i

7. A versão é definida nesta linha:

const version string = "1.0.0"

Atualize a versão para:

const version string = "2.0.0"

8. Salve o arquivo main.go de novo, pressione a tecla Esc e use:

:wq

Tarefa 10: iniciar implantação

Nesta tarefa, você implanta o ambiente de desenvolvimento.

1. Confirme e envie suas alterações por push:

git add Jenkinsfile html.go main.go git commit -m "Version 2.0.0" git push origin new-feature

Isso inicia uma criação do seu ambiente de desenvolvimento.

Depois de enviar a mudança por push ao repositório do Git, acesse a interface de usuário do Jenkinss. A criação da ramificação new-feature terá sido iniciada. Pode levar até um minuto para que as alterações sejam detectadas.

2. Depois que o build estiver em execução, clique na seta para baixo ao lado do build na navegação à esquerda e selecione Console output:

3. Acompanhe a resposta do build por alguns minutos e aguarde o início das mensagens kubectl --namespace=new-feature apply.... A ramificação "new-feature" foi implantada no cluster.

Observação: em um cenário de desenvolvimento, você não usaria um balanceador de carga voltado para o público. Para proteger o aplicativo, é possível usar o proxy kubectl. O proxy faz a própria autenticação com a API Kubernetes e retransmite as solicitações da máquina local para o serviço no cluster sem expor seu serviço à Internet.

Se nada aparecer em Build Executor, não se preocupe. Acesse a página inicial do Jenkins > app de exemplo. Verifique se o pipeline new-feature foi criado.

4. Assim que tudo estiver pronto, inicie o proxy em segundo plano:

kubectl proxy &

5. Se o processo parar, pressione as teclas CTRL+C para sair. Verifique se é possível acessar o aplicativo enviando uma solicitação para localhost e permitindo que o proxy kubectl o encaminhe para seu serviço:

curl \ http://localhost:8001/api/v1/namespaces/new-feature/services/gceme-frontend:80/proxy/version

A resposta "2.0.0" será exibida, que é a versão em uso no momento.

Se você receber um erro semelhante a este:

{ "kind": "Status", "apiVersion": "v1", "metadata": { }, "status": "Failure", "message": "no endpoints available for service \"gceme-frontend:80\"", "reason": "ServiceUnavailable", "code": 503

6. Isso significa que o endpoint do front-end ainda não foi propagado. Aguarde um pouco e tente o comando curl mais uma vez. Prossiga quando receber a seguinte resposta:

2.0.0

Pronto. Você configurou o ambiente de desenvolvimento. Agora use o que aprendeu no módulo anterior para implantar uma versão canário e testar um novo recurso.

Clique em Verificar meu progresso para conferir a tarefa realizada. Se você tiver iniciado o build para a ramificação "new-feature", você vai receber uma pontuação de avaliação.

Build para a ramificação new-feature

Tarefa 11: implantar uma versão canário

Você confirmou que seu app está executando o código mais recente no ambiente de desenvolvimento e agora vai implantar esse código no ambiente canário.

1. Crie uma ramificação canário e a envie por push para o servidor do Git:

git checkout -b canary git push origin canary

2. No Jenkins, você vai notar que o pipeline canário foi iniciado. Depois de concluído, verifique o URL de serviço para garantir que parte do tráfego seja atendida pela nova versão. O esperado é que uma em cada cinco solicitações, sem ordem específica, retorne a versão 2.0.0:

export FRONTEND_SERVICE_IP=$(kubectl get -o \ jsonpath="{.status.loadBalancer.ingress[0].ip}" --namespace=production services gceme-frontend) while true; do curl http://$FRONTEND_SERVICE_IP/version; sleep 1; done

3. Se a versão 1.0.0 continuar sendo exibida, execute os comandos acima de novo. Depois de confirmar que está tudo certo, encerre o comando com CTRL+C.

Pronto! Você implantou uma versão canário. Em seguida, implante a nova versão para a produção.

Clique em Verificar meu progresso para conferir a tarefa realizada. Se a implantação da versão canário tiver sido concluída, você vai receber uma pontuação de avaliação.

Implantar uma versão canário

Tarefa 12: implantar para a produção

Agora que a versão canário está pronta e não houve reclamações de clientes, implante-a no restante da sua frota de produção.

1. Crie uma ramificação canário e a envie por push para o servidor do Git:

git checkout master git merge canary git push origin master

No Jenkins, o pipeline mestre foi iniciado.

Clique em Verificar meu progresso para conferir a tarefa realizada. Se você tiver iniciado o pipeline mestre, vai aparecer uma pontuação de avaliação.

Como implantar a versão na produção

2. Após a conclusão, que pode levar alguns minutos, verifique o URL do serviço para garantir que todo o tráfego está sendo atendido pela nova versão 2.0.0.

export FRONTEND_SERVICE_IP=$(kubectl get -o \ jsonpath="{.status.loadBalancer.ingress[0].ip}" --namespace=production services gceme-frontend) while true; do curl http://$FRONTEND_SERVICE_IP/version; sleep 1; done

3. Mais uma vez, se instâncias da versão 1.0.0 forem retornadas, execute os comandos acima de novo. Para interromper esse comando, pressione CTRL+C.

Exemplo de resposta:

gcpstaging9854_student@qwiklabs-gcp-df93aba9e6ea114a:~/continuous-deployment-on-kubernetes/sample-app$ while true; do curl http://$FRONTEND_SERVICE_IP/version; sleep 1; done 2.0.0 2.0.0 2.0.0 2.0.0 2.0.0 2.0.0 ^C

Também é possível navegar para o site em que o aplicativo gceme mostra os cards de informações. A cor do card mudou de azul para laranja.

4. Confira abaixo o comando que foi usado para consultar o endereço IP externo. Cole o IP externo em uma nova guia para que o card de informação apareça:

kubectl get service gceme-frontend -n production

Exemplo de resposta:

Tarefa 13: testar os conhecimentos

Responda às perguntas de múltipla escolha a seguir para reforçar sua compreensão dos conceitos abordados neste laboratório. Use todo o conhecimento adquirido até aqui.

Pronto.

Muito bem! Você implantou seu aplicativo na produção.

Parabéns!

Você concluiu este laboratório prático sobre implantação e uso do Jenkins no Kubernetes Engine para ativar o pipeline de entrega/implantação contínua. Você teve a oportunidade de implantar uma ferramenta DevOps importante no Kubernetes Engine e configurá-la para uso na produção. Você trabalhou com a ferramenta de linha de comando kubectl e as configurações de implantação em arquivos YAML, além de aprender um pouco sobre a configuração de pipelines do Jenkins para desenvolvimento/implantação. Com essa experiência prática, você deve se sentir mais à vontade para usar essas ferramentas no seu trabalho de DevOps.

Próximas etapas / saiba mais

• Leia mais sobre a solução Jenkins no Kubernetes Engine.
• Saiba como usar o Jenkins para ativar a entrega contínua no Kubernetes Engine.
• Leia mais em Guias e soluções de DevOps na documentação do Google Cloud.
• Conheça a comunidade do Jenkins (página em inglês).

Treinamento e certificação do Google Cloud

Esses treinamentos ajudam você a aproveitar as tecnologias do Google Cloud ao máximo. Nossas aulas incluem habilidades técnicas e práticas recomendadas para ajudar você a alcançar rapidamente o nível esperado e continuar sua jornada de aprendizado. Oferecemos treinamentos que vão do nível básico ao avançado, com opções de aulas virtuais, sob demanda e por meio de transmissões ao vivo para que você possa encaixá-las na correria do seu dia a dia. As certificações validam sua experiência e comprovam suas habilidades com as tecnologias do Google Cloud.

Manual atualizado em 20 de maio de 2026

Laboratório testado em 26 de fevereiro de 2026

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 produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.