Observação:

Implantar no OCI Container Engine for Kubernetes em GitLab CI/CD

Introdução

No cenário em rápida evolução do DevOps e do desenvolvimento nativo da nuvem, a necessidade de integração simplificada entre sistemas de controle de versão e plataformas de orquestração de contêineres pode ser fundamental. O Oracle Cloud Infrastructure Container Engine for Kubernetes (OKE) oferece uma solução robusta e escalável para gerenciar aplicativos em contêineres. No entanto, algumas equipes podem ter preferências e requisitos específicos que os levam a procurar alternativas aos serviços DevOps nativos da Oracle Cloud Infrastructure (OCI).

GitLab é uma plataforma versátil e abrangente de controle de versão, integração contínua e entrega/implantação contínua (CI/CD) que não apenas atende a essas preferências, mas também fornece uma alternativa atraente aos serviços DevOps da OCI. Neste tutorial, orientaremos você no processo de conexão perfeita do GitLab com o Oracle Cloud Infrastructure Container Engine for Kubernetes (OKE). A integração apresentada neste tutorial não só se alinha para usar uma solução GitLab já existente que você pode ter em vigor, mas também capacita a equipe com uma solução unificada para controle de versão, integração contínua e orquestração do Kubernetes.

Nas seções subsequentes, este tutorial apresenta duas abordagens distintas destinadas a fazer essa integração.

Objetivos

Pré-requisitos

Abordagem 1: Implantar no OKE a partir de GitLab CI/CD usando token gerado de curta duração

Tarefa 1: Preparar a Instância do OCI Compute

Você precisará de uma instância do OCI Compute para o Executor GitLab, por exemplo, uma máquina virtual (VM).

Instância de Computação do OCI

  1. Instale o kubectl na VM. Para obter mais informações, consulte Instalar e Configurar kubectl no Linux.

  2. Instale a CLI do OCI e crie o arquivo de configuração para autenticação na tenancy do OCI (ou você será solicitado a criá-lo ao executar as etapas de acesso ao cluster). Para obter mais informações, consulte Instalar a CLI do OCI e Arquivo de Configuração do SDK e da CLI.

  3. Configurar o acesso ao cluster do OKE. Vá para Acessar Seu Cluster e clique em instruções de Acesso Local na Console do OCI.

    Cluster de Acesso do OCI OKE

  4. Instale o GitLab Runner na VM. Execute os comandos a seguir como root.

    sudo curl -L https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.rpm.sh | sudo bash
sudo yum install -y gitlab-runner

    Verifique se o GitLab Runner funciona.

    gitlab-runner list

Tarefa 2: Configurar Executor e Projeto do GitLab

  1. Faça log-in em GitLab, vá para Projetos e crie um novo projeto ou use um existente.

    GitLab Projeto

  2. Crie um corredor ou use um corredor existente. Para criar um novo executor, vá para Definições, CI/CD, Executores e Expandir. Clique em Novo Executor de Projeto e selecione Plataforma (por exemplo: Linux), adicione uma Tag que usaremos posteriormente no arquivo .gitlab-ci.yaml ao configurar seu pipeline de implantação e clique em Criar executor.

    GitLab Executor

  3. Registre o executor na VM.

    Observação: Anote o token de autenticação do executor caso precise dele posteriormente.

    Registre o corredor

    • Execute o comando gitlab-runner register e insira as informações a seguir.

      • GitLab URL da instância: Aceite o valor padrão https://gitlab.com.
      • Nome do Executor: Válido localmente no arquivo config.toml. Por exemplo: gitlab-oke-runner.
      • Informe um Executor: shell, com esse valor, você escolhe que as instruções de CI/CD serão executadas na máquina local em que o kubectl e a CLI do OCI estão instalados.

      Registre o corredor

    • Você pode revisar a configuração do executor no arquivo $HOME/.gitlab-runner/config.toml.

Tarefa 3: Configurar o pipeline de CI/CD

  1. Clone o projeto GitLab em sua máquina local.

  2. Crie um arquivo chamado .gitlab-ci.yaml no diretório do projeto, contendo as instruções de build e implantação. Na seção de implantação, certifique-se de incluir a tag runner que você definiu ao criar o runner antes.

    $ cat ~/demo-oke/.gitlab-ci.yml
stages:
  - build
  - deploy

build_job:
  stage: build
  script:
    - echo "Building the ServiceAccount project..."

deploy_job:
  stage: deploy
  script:
    - echo "Deploying an nginx pod to the OKE cluster"
    - kubectl run nginx --image=nginx
  tags:
    - shell-executor

  3. Envie as alterações ao seu projeto GitLab e vá para Criar e Jobs para verificar se os pipelines de build e implantação foram acionados e executados com sucesso.

    Pipelines CICD

    Implantar job

    O pipeline implantou um pod nginx no cluster do OKE.

    Observações: Anote a tag e a chave. Vamos escolher o executor shell que fará uso dos recursos da máquina local. Caso contrário, se você escolher o Docker, por exemplo, precisará fornecer em suas instruções uma imagem que instale o kubectl (e a CLI do OCI para a abordagem 1) no contêiner.

    $ kubectl get pods
NAME    READY   STATUS    RESTARTS   AGE
nginx   1/1     Running   0          47h

Abordagem 2: Implantar no OKE em GitLab CI/CD usando uma Conta de Serviço do Kubernetes

Repita as Tarefas 1,2 e 3 da Abordagem 1 para configurar a VM local (instalar kubectl, CLI do OCI, GitLab Runner), registrar o executor, criar o arquivo de pipeline .gitlab-ci.yaml.

Tarefa 1: Criar uma Conta de Serviço do Kubernetes e adicionar seu Token

Quando você usa uma conta de serviço do Kubernetes para implantar no OKE em GitLab, o processo envolve a autenticação de GitLab com o cluster do Kubernetes usando as credenciais da conta de serviço.

Próximas Etapas

Usando essas tarefas, você pode usar seu pipeline de CI/CD GitLab para implantar no OKE. Essas tarefas podem ser consideradas como referência para outras ferramentas de CI/CD. A integração facilita a integração e a entrega contínuas, permitindo uma rápida iteração e implantação de aplicativos no OKE.

Neste tutorial, as instruções empregam um executor de shell para testar e lidar com cenários diretos. Como alternativa, você pode optar por outro executor, por exemplo, um executor do Docker. Nesse caso, o pipeline é executado em um contêiner do Docker em vez de na máquina local. A execução com um executor do Docker precisará especificar uma imagem do Docker que inclua os utilitários necessários. Consequentemente, a criação de uma imagem personalizada pode ser essencial, incorporando ferramentas como kubectl e CLI do OCI para atender aos requisitos específicos do pipeline.

Confirmações

Mais Recursos de Aprendizagem

Explore outros laboratórios em docs.oracle.com/learn ou acesse mais conteúdo de aprendizado gratuito no canal Oracle Learning YouTube. Além disso, visite education.oracle.com/learning-explorer para se tornar um Oracle Learning Explorer.

Para obter a documentação do produto, visite o Oracle Help Center.