Geekly articles weekly

CI / CD com AWS e Bamboo

Nossa equipe é composta por um desenvolvedor e um engenheiro de DevOps. Sou responsável pela implantação do aplicativo no cluster Amazon ECS. Como servidor de CI / CD, eu uso o Bamboo. Neste artigo, descreverei em detalhes como implanto um aplicativo em um ambiente de desenvolvimento.





Criar uma imagem do Docker


Aqui eu sigo estas etapas:

  • Etapa 1: instalar e configurar o Docker;
  • Etapa 2: configurar artefatos no Bamboo;
  • Etapa 3: configurar o repositório Amazon ECR;
  • Etapa 4: crie a imagem do Docker no Bamboo.

Etapa 1: Instalar e configurar o Docker


Primeiro, atualizo o servidor em que o Bamboo está instalado, instalo os pacotes necessários e configuro o repositório do Docker. Observe que eu instalei o Bamboo no sistema operacional CentOS 7. Informações sobre a instalação do docker em outros sistemas operacionais podem ser encontradas em www.docker.com .

$ sudo yum update $ sudo yum install -y yum-utils device-mapper-persistent-data lvm2 $ sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

Em seguida, instalo o aplicativo Docker e inicio o serviço:

 $ sudo yum install docker-ce docker-ce-cli containerd.io $ sudo systemctl enable docker $ sudo systemctl start docker

Em seguida, adiciono o usuário de bambu ao grupo Docker:

 $ sudo usermod -aG docker bamboo $ sudo su - bamboo $ docker run hello-world

Se, depois de executar esses comandos, o docker responder com a mensagem "Hello from Docker!", Isso significa que minha instalação está funcionando corretamente.

Etapa 2. Configurar artefatos no Bamboo


O desenvolvimento de aplicativos está em andamento na Grails . Ao compilar o aplicativo, um arquivo com a extensão war é criado. Esse arquivo, na terminologia Bamboo, é um artefato. Configure o Bamboo para usar este arquivo nas tarefas subseqüentes. Para fazer isso, vou para a guia Tarefas :



E eu configurei a tarefa Grails, como mostrado abaixo:



Vemos que o Grails limpa primeiro a pasta de compilação, depois executa os testes e, finalmente, cria um arquivo de guerra para o ambiente de desenvolvimento.

Depois disso, clico na guia Artefatos e no botão Criar artefato :



Eu defino um artefato como mostrado abaixo:



Grails coloca o arquivo war no diretório build / libs . Vou verificar o parâmetro Shared , pois precisarei desse artefato mais tarde.

Agora estou criando um projeto de implantação e especificando um artefato para usar no meu plano de construção:





Também configurei a tarefa de download de artefato no projeto de implantação:



Portanto, o Bamboo agora está configurado para usar um arquivo war.

Etapa 3. Configure o repositório Amazon ECR


O Amazon ECR é um serviço de armazenamento e gerenciamento do Docker para imagens. Para configurar, abra o console da AWS e selecione ECR:



Depois de criar o repositório, recebo o seguinte endereço:

 aws_account_id.dkr.ecr.us-east-2.amazonaws.com/onboard

Depois de concluir a configuração, aqui também é possível encontrar instruções sobre como efetuar login, como baixar uma imagem do repositório e fazer upload da imagem no repositório.

Etapa 4: criar a imagem do Docker em bambu


Agora preciso configurar o gatilho para começar a criar a imagem do Docker. Para fazer isso, vou para a guia Triggers e clique no botão Add trigger :



Aqui, seleciono a opção Compilar após criar com êxito o plano, para que a imagem do Docker seja criada após a compilação do projeto.

Agora precisamos adicionar a tarefa de criação de imagem do Docker. Para fazer isso, vá para a guia Tarefas , clique em Adicionar tarefa , selecione o tipo de Docker . Digite uma descrição e selecione Construir uma imagem do Docker no menu suspenso. No campo Repositório , insira

  aws_account_id.dkr.ecr.us-east-2.amazonaws.com/onboard:latest.

Quanto ao Dockerfile, pode ser como mostrado abaixo:

 FROM openjdk:8-jre COPY *.war /usr/src/onboard.war WORKDIR /usr/src CMD ["/bin/bash", "-c", "java -DdataSource.url=$DATASOURCE_URL -DdataSource.username=$DATASOURCE_USERNAME -DdataSource.password=$DATASOURCE_PASSWORD -jar onboard.war"]

Ao iniciar o aplicativo, você deve especificar o banco de dados. As variáveis ​​de ambiente DATASOURCE_URL, DATASOURCE_USERNAME, DATASOURCE_PASSWORD são usadas para transmitir essas informações ao aplicativo, mas seus valores são definidos quando o contêiner é iniciado.

Isso conclui o processo de instalação para montar a imagem do Docker com o aplicativo. A próxima etapa é configurar o download desta imagem no repositório do Amazon ECR.



Carregar imagem no Elastic Container Registry


Você pode usar o Elastic Container Registry para armazenar imagens coletadas usando o Bamboo. Para conseguir isso, sigo estas etapas:

  • Etapa 1. Instale o Auxiliar de credencial do Amazon ECR Docker
  • Etapa 2. Conecte a função IAM ao servidor Bamboo
  • Etapa 3: configurar a tarefa de inicialização da imagem do Docker

Etapa 1. Instale o Auxiliar de credencial do Amazon ECR Docker


Para baixar imagens do Docker para o Amazon ECR, é necessário ter credenciais. Essas credenciais podem ser obtidas executando o comando

 aws ecr get-login

No entanto, essas credenciais são válidas apenas por 12 horas. Portanto, você pode executar o comando acima toda vez antes de carregar a imagem no ECR ou instalar o ECR Docker Credential Helper, que mantém as credenciais temporárias atualizadas e efetua login no ECR. Siga estas etapas para instalar o ECR Docker Credential Helper.

Primeiro você precisa instalar o git e depois clonar o repositório do github:

 $ sudo yum install git $ sudo su - bamboo $ git clone https://github.com/awslabs/amazon-ecr-credential-helper.git $ make docker

Então você precisa colocar as seguintes linhas no arquivo /home/bamboo/.docker/config.json :

 { "credsStore": "ecr-login" }

E copie o aplicativo compilado no diretório / usr / bin :

 $ exit $ sudo cp /home/bamboo/docker-credential-ecr-login /usr/bin/

Etapa 2. Conecte a função IAM ao servidor Bamboo


Para que o servidor Bamboo possa usar o ECR, você precisa criar uma função, adicionar a política AmazonEC2ContainerRegistryPowerUser a essa função e anexar essa função à instância do EC2 Bamboo. Abra o console da AWS e selecione IAM. Em seguida, clique no botão Criar função , selecione Serviço da AWS e EC2 , conforme mostrado abaixo:



Em seguida, clicamos no botão Avançar: permissões e, na próxima tela, encontramos e selecionamos a política AmazonEC2ContainerRegistryPowerUser . Depois disso, terminamos de criar a função e a anexamos ao nosso servidor Bamboo.

Etapa 3: configurar a tarefa de inicialização da imagem do Docker


O aplicativo que criamos e montamos uma imagem do Docker com um arquivo de guerra. Agora você precisa fazer o upload desta imagem no repositório. Para fazer isso, adiciono outra tarefa do Docker, desta vez para carregar a imagem no repositório do ECR. Vou para a guia Tarefas , clique em Adicionar tarefa , selecione o tipo de Docker . Entro em uma descrição e selecione Enviar uma imagem do Docker para um registro do Docker no menu suspenso. Seleciono Registro personalizado e insiro o endereço do repositório no campo Repositório . Para o tipo de autenticação, selecione Usar credenciais nativas do agente .

Isso conclui o processo de instalação para carregar a imagem do Docker no repositório do Amazon ECR. As etapas a seguir descrevem o processo de configuração de um cluster e serviço para iniciar um aplicativo de contêiner. Mas antes disso, você precisa configurar as opções de inicialização para o contêiner. É isso que faremos agora.



Criar definição de tarefa do Amazon ECS


Definição da tarefa - os parâmetros de execução do contêiner são gravados aqui. Nosso aplicativo usa um banco de dados cujos parâmetros são especificados quando o contêiner inicia, portanto nesta seção também criaremos um banco de dados. Uso o Amazon RDS como banco de dados e guardo a senha para acessar o banco de dados em formato criptografado no AWS Systems Manager Parameter Store . As etapas a seguir, seguidas para criar uma definição de tarefa:

  • Etapa 1. Criando um banco de dados em uma instância do Amazon RDS;
  • Etapa 2. Configurando o armazenamento de parâmetros do AWS Systems Manager;
  • Etapa 3. Crie uma definição de tarefa.

Etapa 1. Crie um banco de dados em uma instância do Amazon RDS


Nosso aplicativo usa o banco de dados PostgreSQL. Para criar um banco de dados, abra o console da AWS, selecione o serviço Amazon RDS, clique no botão Criar banco de dados e selecione PostgreSQL como o mecanismo de banco de dados. Na próxima página, selecione Dev / Test como o ambiente de trabalho e clique em Avançar . Em seguida, designo o identificador da instância do banco de dados como onboard-dev-db e o nome de usuário mestre como devdbadmin . Depois, vou para a próxima página para configurar a VPC, o grupo de sub-rede e o grupo de segurança. Esse banco de dados será usado em uma rede privada, portanto, seleciono Não para o parâmetro Acessibilidade pública . Entro devdb no campo Nome do banco de dados e clique no botão Criar banco de dados .

Etapa 2. Configurando o armazenamento de parâmetros do AWS Systems Manager


Eu guardo a senha do banco de dados em forma criptografada. Para fazer isso, abra o console da AWS e vá para AWS Systems Manager → Recursos compartilhados → Armazenamento de parâmetros → Criar parâmetro. Entro devdbpassword como o nome do parâmetro e seleciono SecureString para o tipo de parâmetro, depois digito a senha do banco de dados no campo Valor .

Etapa 3. Criar definição de tarefa


O Amazon ECS é o cluster em que os aplicativos de contêiner são executados. Ele usa a Definição de tarefa para especificar parâmetros de execução para um aplicativo de contêiner. Para definir esses parâmetros, clique no botão Criar nova definição de tarefa . Depois, seleciono Fargate como o tipo de inicialização e prossigo para a próxima etapa. Aqui, defino o nome como onboard-dev-taskdef . Para o parâmetro do campo de função IAM de execução de tarefas , selecione Criar nova função . Quanto aos recursos alocados para este aplicativo, designo 2 GB de memória e 1 vCPU. Agora você precisa adicionar opções de inicialização de contêiner. Vou nomear o contêiner onboard-dev-container . Vou nomear o nome da imagem assim:

aws_account_id.dkr.ecr.us-east-2.amazonaws.com/onboard:latest . O Auxiliar de credencial do Amazon ECR Docker cuidará da autenticação de ECR; portanto, deixo a opção de autenticação de repositório particular desmarcada. No ambiente de desenvolvimento, o aplicativo está disponível na porta 8080, portanto, para o parâmetro de mapeamentos de portas, escrevo 8080 e seleciono o protocolo tcp . Os parâmetros de URL do banco de dados, nome de usuário e senha são passados ​​para o contêiner usando variáveis ​​de ambiente. Defino esses parâmetros na seção Variáveis ​​de ambiente. Para obter o valor do parâmetro devdbpassword do Parameter Store, especifique o tipo ValueFrom . A última coisa que eu configuro é a configuração de log , aqui seleciono Configurar automaticamente os logs do CloudWatch . Agora a criação da definição de tarefa está concluída.

No entanto, a função ecsTaskExecutionRole precisa de uma política para obter devdbpassword do Armazenamento de Parâmetros. Para fazer isso, acesse Funções do IAM e selecione ecsTaskExecutionRole, clique em Adicionar política embutida . Neste caso, estou adicionando usando um editor visual. Portanto, no campo Serviço, insiro o Systems Manager , no campo Ações - GetParameters . Em seguida, clique em Adicionar ARN para o campo Recursos e preencha meus valores:



No final, eu olho para os valores dos parâmetros definidos clicando em Política de Revisão, atribua um nome e termine de trabalhar com a configuração ecsTaskExecutionRole.

Isso conclui a configuração das configurações do aplicativo de contêiner de inicialização. Agora você precisa criar um cluster e serviço ECS.



Criar serviço Amazon ECS


Nosso aplicativo de contêiner é executado como um serviço em um cluster ECS. Para configurar, você deve executar as seguintes etapas:

  • Etapa 1. Crie um cluster do Amazon ECS;
  • Etapa 2: Criando um Serviço

Etapa 1. Crie um cluster do Amazon ECS


Para criar um cluster ECS, acesse o console da AWS e selecione o serviço ECS. Em seguida, clique em Criar cluster e selecione o modelo de cluster Somente para rede . Na próxima página, nomeio o cluster como onboard-dev-cluster e concluo o cluster. Agora eu tenho um cluster ECS baseado em Fargate .

Etapa 2: Criando um Serviço


Para criar um serviço, clique no link onboard-dev-cluster , depois vá para a guia Serviços e clique no botão Criar . Para o tipo de inicialização, selecione Fargate, para Definição da tarefa, selecione onboard-dev-taskdef. Além disso, seleciono onboard-dev-cluster no campo Cluster. No campo Nome do serviço , escrevo onboard-dev. Defino o parâmetro Número de tarefas como zero, pois não quero iniciar o aplicativo agora. Deixo os parâmetros Porcentagem Mínima Saudável para 100 e Porcentagem Máxima para 200. Para o parâmetro Tipo de implantação , selecione Atualização sem interrupção e vá para a próxima etapa.

Na página Configurar Rede , para o parâmetro Cluster VPC , seleciono um VPC criado anteriormente chamado Development VPC . O aplicativo em desenvolvimento está disponível apenas na rede privada, por isso escolhi duas sub-redes privadas. Para configurar grupos de segurança, clique no botão Editar , selecione Selecionar grupo de segurança existente , depois no grupo de segurança padrão e clique no botão Salvar . Para o parâmetro IP público de atribuição automática , selecione Desativado . Em seguida, para o parâmetro Tipo de balanceador de carga , seleciono Nenhum e deixo a opção Ativar integração de descoberta de serviço desmarcada . Em seguida, clique em Avançar, Avançar e Criar serviço .

Agora eu tenho um serviço no qual o número de trabalhos em execução é zero. Vamos configurar o lançamento do aplicativo na próxima etapa.



Atualização de Serviço


Assim que o desenvolvedor atualiza o código do aplicativo, nossa implantação passa pela criação de uma imagem do Docker, pelo upload no Elastic Container Registry e, finalmente, pelo lançamento do aplicativo de contêiner como um serviço no cluster do ECS Fargate. No momento, o número de trabalhos em execução no cluster é zero. Para que o aplicativo inicie, você precisa atualizar o serviço, indicando a quantidade igual a um. Eu sigo estas etapas para conseguir isso:

  • Etapa 1. Instalando o plug-in Tarefas para o AWS Bamboo;
  • Etapa 2. Atualizando o serviço ECS

Etapa 1. Instalando o plug-in Tarefas para o AWS Bamboo


Tarefas para o AWS Bamboo é um plug-in que simplifica a preparação e operação dos recursos da AWS nos projetos de construção e implantação do Bamboo. Para instalar esse plug-in, vou ao projeto de implantação, clique em Adicionar tarefa , vá ao Atlassian Marketplace e instale o Tasks for AWS (Bamboo) .

Etapa 2. Atualizando o serviço ECS


Agora, no projeto de implantação, estou adicionando o trabalho do Amazon ECS Service . Depois, escrevo no campo de descrição do trabalho Update Service para onBoard-dev . No campo Ação, selecione Serviço de atualização e Forçar nova implantação . Depois, seleciono Leste dos EUA (Ohio) como região de lançamento. Depois, escrevo nos campos apropriados ARN (Amazon Resource Name) para definição de tarefas, cluster e serviço. Nesta tarefa, atualizo o número desejado de tarefas em execução para um. Em seguida, preencho a caixa de texto de configuração de implantação com os seguintes valores:

 { "maximumPercent": 200, "minimumHealthyPercent": 100 }

Estou configurando uma rede sem um IP público da seguinte maneira:

 { "awsvpcConfiguration": { "assignPublicIp": "DISABLED", "subnets": ["subnet-ID1", "subnet-ID2"], "securityGroups": ["sg-ID"] } }

Na seção Origem das credenciais de segurança da AWS, seleciono Função do IAM para EC2 .

Preciso poder atualizar o ECS, por isso estou anexando a política AmazonECS_FullAccess à minha instância do Bamboo EC2. Para fazer isso, abra o console da AWS, selecione IAM. Depois, seleciono a função que uso no meu servidor Bamboo. Clico no botão Anexar políticas , encontro a política AmazonECS_FullAccess, seleciono a caixa de seleção à esquerda e termino de anexar a política.

Isso conclui a configuração do CI / CD usando o AWS e o Bamboo. Assim, quando o desenvolvedor atualiza o código do aplicativo, ele é carregado no repositório, o teste e a montagem do aplicativo são iniciados. Em seguida, a imagem do Docker é criada com o arquivo war do aplicativo e é copiada para o repositório do Amazon ECR. Em seguida, no cluster Amazon ECS, um aplicativo de contêiner é iniciado como um serviço, que atualiza o aplicativo atual se não tiver sido parado. Se o aplicativo foi parado para economizar recursos, ele simplesmente é iniciado. Após verificar o aplicativo no ambiente de desenvolvimento, é possível parar o aplicativo especificando o número de tarefas em execução no cluster para zero.

Se você gostou do artigo e tem idéias para melhorias, escreva nos comentários.

Source: https://habr.com/ru/post/pt458648/

More articles:


All Articles