Como conectar GitLab e Pantheon e otimizar fluxos de trabalho Drupal e WordPress

Nosso criador convidado de ferramentas para desenvolvedores na Pantheon fala sobre como automatizar implantações do WordPress usando GitLab CI/CD.

В Panteão Eu trabalho com relações com desenvolvedores, por isso estou sempre procurando novas maneiras de ajudar desenvolvedores de WordPress e Drupal a resolver problemas de automação em seus fluxos de trabalho. Para fazer isso, gosto de experimentar novas ferramentas e combiná-las para funcionar de forma eficaz.

Muitas vezes vejo desenvolvedores lutando com um único servidor de teste.

É um prazer esperar a sua vez de usar um servidor intermediário ou enviar aos clientes uma URL com a nota: “Olhe aqui, mas não olhe aqui ainda”.

Ambientes multidesenvolvimento - uma das ferramentas legais do Pantheon - resolve esse problema, pois com elas você pode criar ambientes para ramificações Git sob demanda. Cada ambiente multidev tem seu próprio URL e banco de dados, para que os desenvolvedores possam trabalhar silenciosamente, verificar a qualidade e obter aprovação sem atrapalhar uns aos outros.

Mas a Pantheon não possui ferramentas para controle de versão ou integração e implantação contínua (CI/CD). Mas é uma plataforma flexível com a qual você pode integrar qualquer ferramenta.

Notei também que as equipes usam certas ferramentas para desenvolvimento e outras diferentes para montagem e implantação.

Por exemplo, eles possuem diferentes ferramentas para controle de versão e CI/CD. Você precisa mexer e alternar entre ferramentas para editar código e diagnosticar problemas.

На GitLab há um conjunto completo de ferramentas de desenvolvimento: para controle de versão, tickets, solicitações de mesclagem, o melhor pipeline de CI/CD da categoria, registro de contêiner e tudo mais. Ainda não encontrei um aplicativo que ofereça tanto para gerenciar seu fluxo de trabalho de desenvolvimento.

Adoro automação, então aprendi como conectar o Pantheon ao GitLab para que os commits na ramificação principal do GitLab sejam implantados no ambiente de desenvolvimento principal do Pantheon. E as solicitações de mesclagem no GitLab podem criar e implantar código em ambientes multidev no Pantheon.

Neste tutorial, mostrarei como configurar uma conexão entre GitLab e Pantheon e otimizar seu fluxo de trabalho WordPress e Drupal.

Claro que é possível, espelhar repositório GitLab, mas faremos tudo com as mãos para nos aprofundar CI do GitLab e no futuro usar esta ferramenta não apenas para implantação.

Introdução

Para esta postagem, você precisa entender que a Pantheon divide cada site em três elementos: código, banco de dados e arquivos.

O código inclui arquivos CMS, como núcleo do WordPress, plug-ins e temas. Esses arquivos são gerenciados em Repositórios Git, hospedado pela Pantheon, o que significa que podemos implantar código do GitLab no Pantheon com Git.
Os arquivos no Pantheon são arquivos de mídia, ou seja, imagens do site. Normalmente eles são carregados pelos usuários e o Git os ignora.

Criar uma conta gratuita, saiba mais sobre Fluxo de trabalho do Panteão ou inscreva-se para uma demonstração em pantheon.io.

Suposições

Meu projeto no Pantheon e GitLab se chama pantheon-gitlab-blog-demo. O nome do projeto deve ser exclusivo. Aqui trabalharemos com um site WordPress. Você pode usar o Drupal, mas precisará mudar algumas coisas.

usarei Linha de comando do Gite você pode trabalhar em interface gráfica, se você quiser.

Crie um projeto

Primeiro, vamos criar Projeto GitLab (voltaremos a isso mais tarde).

Agora criando um site WordPress no Pantheon. Em seguida, instalamos o WordPress para o painel do site.

Se suas mãos estão ansiosas para mudar alguma coisa, por exemplo, remover ou adicionar plug-ins, seja paciente. O site ainda não está conectado ao GitLab e queremos que todas as alterações de código passem pelo GitLab.

Depois de instalar o WordPress, volte ao painel do site Pantheon e mude o modo de desenvolvimento para Git.

Confirmação inicial no GitLab

Agora você precisa transferir o código inicial do WordPress do site Pantheon para o GitLab. Para fazer isso, clonamos localmente o código do repositório Git do site Pantheon e depois o enviamos para o repositório GitLab.

Para tornar tudo mais fácil e seguro, adicione uma chave SSH ao Pantheon e não precisaremos inserir uma senha toda vez que clonarmos um repositório Pantheon Git. Ao mesmo tempo já adicione uma chave SSH ao GitLab.

Para fazer isso, clone o site Pantheon localmente, copiando o comando do campo Clonar com Git no painel do site.

Se precisar de ajuda, leia a documentação começando com Git para Pantheon.

Agora vamos mudar git remote originapontar para o GitLab em vez do Pantheon. Pode ser feito командой git remote.

Vamos para o projeto GitLab e copiar a URL do repositório no menu suspenso Clone na página de detalhes do projeto. Vamos escolher a opção Clonar com SSH, pois já configuramos a chave SSH.

Por padrão git remote para uma cópia local do repositório de código - origin. Isso pode ser alterado c git remote set-url origin [URL репозитория GitLab], onde, em vez de colchetes, inserimos o URL real.

Por fim, lançamos git push origin master --forcepara enviar o código WordPress do Pantheon para o GitLab.

A opção –force só é necessária uma vez. Então em equipes git push não estará no GitLab.

Configurando credenciais e variáveis

Lembra como adicionamos uma chave SSH localmente para fazer login no Pantheon e no GitLab? O token SSH pode ser usado para autorizar GitLab e Pantheon.

GitLab possui excelente documentação. Vamos ver seção sobre chaves SSH ao usar o executor Docker no documento sobre como usar chaves SSH com GitLab CI/CD.

Agora concluiremos as duas primeiras etapas: Vamos criar um novo par de chaves SSH localmente com ssh-keygen e adicionar a chave privada como uma variável ao projeto.

Então vamos perguntar SSH_PRIVATE_KEY como Variável de ambiente CI/CD do GitLab nas configurações do projeto.
Na terceira e quarta etapas criaremos um arquivo .gitlab-ci.yml com conteúdo como este:

before_script:
  # See https://docs.gitlab.com/ee/ci/ssh_keys/README.html
  - eval $(ssh-agent -s)
  - echo "$SSH_PRIVATE_KEY" | tr -d 'r' | ssh-add - > /dev/null
  - mkdir -p $HOME/.ssh && echo "StrictHostKeyChecking no" >> "$HOME/.ssh/config"
  - git config --global user.email "$GITLAB_USER_EMAIL"
  - git config --global user.name "Gitlab CI"

Não vamos submeter o arquivo ainda .gitlab-ci.yml, então você precisará adicionar algo mais a ele.

Agora realizamos o quinto passo e adicione a chave pública que você criou na primeira etapa aos serviços aos quais você precisa acessar no ambiente de construção.

No nosso caso, queremos acessar o Pantheon do GitLab. Seguimos as instruções do documento Pantheon em adicionando uma chave SSH ao Pantheon e execute esta etapa.

Lembre-se: o SSH privado está no GitLab, o SSH aberto está no Pantheon.

Vamos configurar mais algumas variáveis ​​de ambiente. O primeiro é chamado PANTHEON_SITE. Seu valor é o nome do site Pantheon em sua máquina.

O nome na máquina está listado no final do comando Clonar com Git. Você já clonou o site localmente, então este será o nome do diretório do repositório local.

A seguir, vamos configurar a variável de ambiente PANTHEON_GIT_URL. Este é o URL do repositório Git do site Pantheon que já usamos.

Insira apenas o URL do repositório SSH, sem git clone e o nome do site na máquina no final.

Ufa. Pronto, agora podemos finalizar nosso arquivo .gitlab-ci.yml.

Crie uma tarefa de implantação

O que faremos inicialmente com o GitLab CI é muito semelhante ao que fizemos com os repositórios Git no passado. Mas desta vez, vamos adicionar o repositório Pantheon como uma segunda fonte Git remota e, em seguida, enviar o código do GitLab para o Pantheon.

Para fazer isso, vamos configurar etapa deploy и tarefa deploy:dev, porque iremos implantar no ambiente de desenvolvimento no Pantheon. O arquivo resultante .gitlab-ci.yml será parecido com este:

stages:
- deploy

before_script:
  # See https://docs.gitlab.com/ee/ci/ssh_keys/README.html
  - eval $(ssh-agent -s)
  - echo "$SSH_PRIVATE_KEY" | tr -d 'r' | ssh-add - > /dev/null
  - mkdir -p $HOME/.ssh && echo "StrictHostKeyChecking no" >> "$HOME/.ssh/config"
  - git config --global user.email "$GITLAB_USER_EMAIL"
  - git config --global user.name "Gitlab CI"

deploy:dev:
  stage: deploy
  environment:
    name: dev
    url: https://dev-$PANTHEON_SITE.pantheonsite.io/
  script:
    - git remote add pantheon $PANTHEON_GIT_URL
    - git push pantheon master --force
  only:
    - master

Variáveis SSH_PRIVATE_KEY, PANTHEON_SITE и PANTHEON_GIT_URL deve parecer familiar - configuramos essas variáveis ​​de ambiente anteriormente. Com essas variáveis ​​poderemos usar os valores do arquivo .gitlab-ci.yml muitas vezes e só precisarão ser atualizados em um só lugar.

Por fim, adicione, confirme e envie o arquivo .gitlab-ci.yml no GitLab.

Verificando a implantação

Se fizéssemos tudo corretamente, a tarefa deploy:dev será executado com sucesso no GitLab CI/CD e enviará um commit .gitlab-ci.yml no Panteão. Vamos dar uma olhada.

Enviando threads de solicitação de mesclagem para o Pantheon

Aqui usaremos meu recurso favorito do Pantheon - multidesenvolvimento, onde você pode criar ambientes Pantheon adicionais para ramificações Git sob demanda.

O acesso ao multidev é limitado, portanto esta seção pode ser ignorada. Mas se você tiver acesso, poderá aumentar seriamente a produtividade configurando a criação automática de ambientes multidev no Pantheon a partir de solicitações de mesclagem do GitLab.

Primeiro vamos criar um novo branch Git localmente usando git checkout -b multidev-support. Agora vamos mudar algo novamente em .gitlab-ci.yml.

Gosto de incluir o número da solicitação de mesclagem no nome do ambiente Pantheon. Por exemplo, a primeira solicitação de mesclagem é mr-1, segundo - mr-2 etc.

A solicitação de mesclagem muda, portanto, precisamos determinar dinamicamente os nomes das filiais do Pantheon. É fácil no GitLab - você só precisa usar variáveis ​​de ambiente predefinidas.

Nós podemos pegar $CI_MERGE_REQUEST_IIDpara especificar o número da solicitação de mesclagem. Vamos aplicar tudo isso junto com as variáveis ​​de ambiente globais que especificamos anteriormente e adicionar uma nova tarefa deploy:multidev no final do arquivo .gitlab-ci.yml.

deploy:multidev:
  stage: deploy
  environment:
    name: multidev/mr-$CI_MERGE_REQUEST_IID
    url: https://mr-$CI_MERGE_REQUEST_IID-$PANTHEON_SITE.pantheonsite.io/
  script:
    # Checkout the merge request source branch
    - git checkout $CI_COMMIT_REF_NAME
    # Add the Pantheon git repository as an additional remote
    - git remote add pantheon $PANTHEON_GIT_URL
    # Push the merge request source branch to Pantheon
    - git push pantheon $CI_COMMIT_REF_NAME:mr-$CI_MERGE_REQUEST_IID --force
  only:
    - merge_requests

Será semelhante à nossa tarefa deploy:dev, apenas a filial é enviada para o Pantheon, não para master.

Adicionamos e confirmamos o arquivo atualizado .gitlab-ci.yml, e agora vamos enviar um novo branch para o GitLab com git push -u origin multidev-support.

Agora vamos criar uma nova solicitação de mesclagem do branch multidev-supportpressionando Criar solicitação de mesclagem.

Depois de criar uma solicitação de mesclagem, veremos como a tarefa CI/CD é executada deploy:multidev.

Olha, um novo tópico foi enviado para a Pantheon. Mas se formos para a seção multidev no painel do site Pantheon, não veremos o novo ambiente lá

Vejamos a seção Git Branches.

Como resultado, nosso tópico mr-1 cheguei ao Panteão. Vamos criar um ambiente a partir de um branch mr-1.

Criamos um ambiente multidev, agora vamos voltar ao GitLab e dar uma olhada na seção Operações > Ambientes. Veremos entradas para dev и mr-1.

Isso ocorre porque adicionamos uma entrada environment Com nome name и url em tarefas de CI/CD. Se clicarmos no ícone do ambiente aberto, seremos levados à URL do ambiente multidev no Pantheon.

Automatize a criação de multidev

Em princípio, você pode parar por aqui e lembrar de criar um ambiente multidev para cada solicitação de mesclagem, mas esse processo pode ser automatizado.

Pantheon tem uma ferramenta de linha de comando término, onde você pode trabalhar com a plataforma automaticamente. Terminus permite criar ambientes multidev a partir da linha de comando - ideal para CI do GitLab.

Precisamos de uma nova solicitação de mesclagem para testar isso. Vamos criar um novo branch usando git checkout -b auto-multidev-creation.

Para usar o Terminus em tarefas de CI/CD do GitLab, você precisa de um token de máquina para autenticação com o Terminus e uma imagem de contêiner com o Terminus.

Criando um token de máquina Pantheon, salve-o em um local seguro e adicione-o como uma variável de ambiente global no GitLab com o nome PANTHEON_MACHINE_TOKEN.

Se você esqueceu como adicionar variáveis ​​de ambiente do GitLab, volte para onde definimos PANTHEON_SITE.

Criando um Dockerfile com Terminus

Se você não usa Docker ou não gosta de arquivos Dockerfile, pegue minha imagem registry.gitlab.com/ataylorme/pantheon-gitlab-blog-demo:latest e pule esta seção.

GitLab possui um registro de contêiner, onde podemos construir e colocar o Dockerfile para nosso projeto. Vamos criar um Dockerfile com Terminus para trabalhar com Pantheon.

Terminus é uma ferramenta de linha de comando PHP, então vamos começar com a imagem PHP. Estou instalando o Terminus através do Composer, então vou usar imagem oficial do Docker Composer. Nós criamos Dockerfile no diretório do repositório local com o seguinte conteúdo:

# Use the official Composer image as a parent image
FROM composer:1.8

# Update/upgrade apk
RUN apk update
RUN apk upgrade

# Make the Terminus directory
RUN mkdir -p /usr/local/share/terminus

# Install Terminus 2.x with Composer
RUN /usr/bin/env COMPOSER_BIN_DIR=/usr/local/bin composer -n --working-dir=/usr/local/share/terminus require pantheon-systems/terminus:"^2"

Siga as instruções de montagem e envio de imagens da seção Crie e envie imagens в documentação de registro de contêinerpara coletar uma imagem de Dockerfile e envie-o para o GitLab.

Abrindo a seção Lista de Presentes no projeto GitLab. Se tudo correr conforme o planejado, nossa imagem estará lá. Anote um link para a tag da imagem - precisamos dele para o arquivo .gitlab-ci.yml.

Seção script no problema deploy:multidev está começando a crescer, então vamos movê-lo para um arquivo separado. Crie um novo arquivo private/multidev-deploy.sh:

#!/bin/bash

# Store the mr- environment name
export PANTHEON_ENV=mr-$CI_MERGE_REQUEST_IID

# Authenticate with Terminus
terminus auth:login --machine-token=$PANTHEON_MACHINE_TOKEN

# Checkout the merge request source branch
git checkout $CI_COMMIT_REF_NAME

# Add the Pantheon Git repository as an additional remote
git remote add pantheon $PANTHEON_GIT_URL

# Push the merge request source branch to Pantheon
git push pantheon $CI_COMMIT_REF_NAME:$PANTHEON_ENV --force

# Create a function for determining if a multidev exists
TERMINUS_DOES_MULTIDEV_EXIST()
{
    # Stash a list of Pantheon multidev environments
    PANTHEON_MULTIDEV_LIST="$(terminus multidev:list ${PANTHEON_SITE} --format=list --field=id)"

    while read -r multiDev; do
        if [[ "${multiDev}" == "$1" ]]
        then
            return 0;
        fi
    done <<< "$PANTHEON_MULTIDEV_LIST"

    return 1;
}

# If the mutltidev doesn't exist
if ! TERMINUS_DOES_MULTIDEV_EXIST $PANTHEON_ENV
then
    # Create it with Terminus
    echo "No multidev for $PANTHEON_ENV found, creating one..."
    terminus multidev:create $PANTHEON_SITE.dev $PANTHEON_ENV
else
    echo "The multidev $PANTHEON_ENV already exists, skipping creating it..."
fi

O script está em um diretório privado e não permite acesso web ao Pantheon. Temos um script para nossa lógica multidev. Vamos agora atualizar a seção deploy:multidev Arquivo .gitlab-ci.ymlpara que fique assim:

deploy:multidev:
  stage: deploy
  environment:
    name: multidev/mr-$CI_MERGE_REQUEST_IID
    url: https://mr-$CI_MERGE_REQUEST_IID-$PANTHEON_SITE.pantheonsite.io/
  script:
    # Run the multidev deploy script
    - "/bin/bash ./private/multidev-deploy.sh"
  only:
    - merge_requests

Precisamos ter certeza de que nossas tarefas são executadas na imagem personalizada criada, então vamos adicionar uma definição image do URL do registro para .gitlab-ci.yml. Como resultado, acabamos com um arquivo como este .gitlab-ci.yml:

image: registry.gitlab.com/ataylorme/pantheon-gitlab-blog-demo:latest

stages:
- deploy

before_script:
  # See https://docs.gitlab.com/ee/ci/ssh_keys/README.html
  - eval $(ssh-agent -s)
  - echo "$SSH_PRIVATE_KEY" | tr -d 'r' | ssh-add - > /dev/null
  - mkdir -p $HOME/.ssh && echo "StrictHostKeyChecking no" >> "$HOME/.ssh/config"
  - git config --global user.email "$GITLAB_USER_EMAIL"
  - git config --global user.name "Gitlab CI"

deploy:dev:
  stage: deploy
  environment:
    name: dev
    url: https://dev-$PANTHEON_SITE.pantheonsite.io/
  script:
    - git remote add pantheon $PANTHEON_GIT_URL
    - git push pantheon master --force
  only:
    - master

deploy:multidev:
  stage: deploy
  environment:
    name: multidev/mr-$CI_MERGE_REQUEST_IID
    url: https://mr-$CI_MERGE_REQUEST_IID-$PANTHEON_SITE.pantheonsite.io/
  script:
    # Run the multidev deploy script
    - "/bin/bash ./private/multidev-deploy.sh"
  only:
    - merge_requests

Adicionar, confirmar e enviar private/multidev-deploy.sh и .gitlab-ci.yml. Agora voltamos ao GitLab e aguardamos a conclusão da tarefa de CI/CD. Seja paciente: o multidev pode levar vários minutos para ser criado.

Então vamos dar uma olhada na lista multidev no Pantheon. Ah, milagre! Ambiente multidesenvolvimento mr-2 já aqui.

Conclusão

Minha equipe se divertiu muito mais quando começamos a abrir solicitações de mesclagem e criar ambientes automaticamente.

Com as ferramentas poderosas do GitLab e Pantheon, você pode conectar o GitLab ao Pantheon automaticamente.

Como usamos GitLab CI/CD, nosso fluxo de trabalho terá espaço para crescer. Aqui estão algumas ideias para você começar:

• Adicione uma etapa de construção.
• Adicione testes automatizados.
• Adicione uma tarefa para garantir que os padrões de código sejam atendidos.
• Adicione um testes dinâmicos de segurança de aplicativos.

Deixe-nos saber o que você pensa sobre GitLab, Pantheon e automação.

PS Você sabia que o Terminus, a ferramenta de linha de comando do Pantheon, pode ser estendido através de plugins?

Nós da Pantheon fizemos um bom trabalho na versão 2 do nosso plugin para ferramentas de construção Terminus com suporte do GitLab. Se você não quer se preocupar com as configurações de cada projeto, experimente este plugin e ajude-nos a testar a versão beta v2. Para a equipe Terminus build:project:create Você só precisa de um token Pantheon e um token GitLab. Ela implantará um dos projetos de amostra com Composer e testes automatizados, criará um novo projeto no GitLab, um novo site Pantheon, e os conectará usando variáveis ​​de ambiente e chaves SSH.

Sobre o autor

Andrew Taylor cria ferramentas para desenvolvedores em Panteão.

Fonte: habr.com