Como conectar GitLab e Pantheon e optimizar os fluxos de traballo de Drupal e WordPress

O noso creador de ferramentas para desenvolvedores convidados en Pantheon fala sobre como automatizar as implementacións de WordPress usando GitLab CI/CD.

В Panteón Traballo nas relacións con desenvolvedores, polo que sempre estou a buscar novas formas de axudar aos desenvolvedores de WordPress e Drupal a resolver problemas de automatización nos seus fluxos de traballo. Para iso, gústame experimentar con novas ferramentas e combinalas entre elas para funcionar de forma eficaz.

Moitas veces vexo que os desenvolvedores loitan cun único servidor de preparación.

É un pracer esperar á túa quenda para usar un servidor intermedio ou enviar aos clientes un URL coa nota: "Mira aquí, pero aínda non mires aquí".

Entornos multidev - unha das fantásticas ferramentas de Pantheon - resolve este problema, porque con elas podes crear ambientes para ramas de Git baixo demanda. Cada ambiente multidev ten o seu propio URL e base de datos, polo que os desenvolvedores poden traballar tranquilamente, comprobar a calidade e obter aprobación sen pisar os dedos dos outros.

Pero Pantheon non dispón de ferramentas para o control de versións nin para a integración e implantación continuas (CI/CD). Pero é unha plataforma flexible coa que podes integrar calquera ferramenta.

Tamén notei que os equipos usan certas ferramentas para o desenvolvemento e outras diferentes para a súa montaxe e despregamento.

Por exemplo, teñen diferentes ferramentas para o control de versións e CI/CD. Ten que xogar e cambiar entre ferramentas para editar o código e diagnosticar problemas.

En GitLab hai un conxunto completo de ferramentas de desenvolvemento: para o control de versións, tickets, solicitudes de combinación, unha canalización de CI/CD mellor da súa clase, un rexistro de contedores e todo iso. Aínda non me atopei cunha aplicación que ofreza tanto para xestionar o teu fluxo de traballo de desenvolvemento.

Encántame a automatización, así que aprendín a conectar Pantheon a GitLab para que os compromisos coa rama principal de GitLab se despreguen no entorno de desenvolvemento principal de Pantheon. E as solicitudes de combinación en GitLab poden crear e implementar código en ambientes multidev en Pantheon.

Neste tutorial, explicarei como configurar unha conexión entre GitLab e Pantheon e optimizar o fluxo de traballo de WordPress e Drupal.

Por suposto que é posible, espello do repositorio de GitLab, pero faremos todo coas nosas mans para afondar GitLab CI e no futuro use esta ferramenta non só para a súa implantación.

Introdución

Para esta publicación, debes entender que Pantheon divide cada sitio en tres elementos: código, base de datos e ficheiros.

O código inclúe ficheiros CMS como o núcleo de WordPress, os complementos e os temas. Estes ficheiros son xestionados en Repositorios Git, aloxado por Pantheon, o que significa que podemos implementar código de GitLab a Pantheon con Git.
Os ficheiros en Pantheon son ficheiros multimedia, é dicir, imaxes para o sitio. Normalmente son cargados polos usuarios e Git ignóraos.

Crea unha conta gratuíta, infórmate sobre Fluxo de traballo do Panteón ou rexistrarte para unha demostración en pantheon.io.

Suposicións

O meu proxecto en Pantheon e GitLab chámase pantheon-gitlab-blog-demo. O nome do proxecto debe ser único. Aquí traballaremos cun sitio WordPress. Podes tomar Drupal, pero terás que cambiar algunhas cousas.

Vou usar Liña de comandos Gite podes traballar interface gráfica, Se ti queres.

Crear un proxecto

Primeiro, imos crear Proxecto GitLab (volveremos sobre isto máis tarde).

Agora creando un sitio web de WordPress en Pantheon. Despois instalamos WordPress para o panel do sitio.

Se as túas mans están desexando cambiar algo, por exemplo, eliminar ou engadir complementos, ten paciencia. O sitio aínda non está conectado a GitLab e queremos que todos os cambios de código pasen por GitLab.

Unha vez que instalemos WordPress, volve ao panel do sitio web de Pantheon e cambia o modo de desenvolvemento a Git.

Commit inicial en GitLab

Agora cómpre transferir o código inicial de WordPress do sitio de Pantheon a GitLab. Para iso, clonamos o código do repositorio Git do sitio de Pantheon localmente e despois enviámolo ao repositorio de GitLab.

Para facelo máis doado e seguro, engadir unha chave SSH a Pantheon e non teremos que introducir un contrasinal cada vez que clonamos un repositorio Pantheon Git. Ao mesmo tempo xa engadir unha chave SSH a GitLab.

Para iso, clone o sitio Pantheon localmente copiando o comando do campo Clonar con Git no panel do sitio.

Se precisas axuda, le a documentación comezando con Git para Pantheon.

Agora imos cambiar git remote originpara apuntar a GitLab en lugar de Pantheon. Pódese facer командой git remote.

Imos ao proxecto GitLab e copie o URL do repositorio do menú despregable Clonar na páxina de detalles do proxecto. Escollemos a opción Clonar con SSH, porque xa temos configurada a chave SSH.

Por defecto git remote para unha copia local do repositorio de código - origin. Isto pódese cambiar c git remote set-url origin [URL репозитория GitLab], onde en lugar de corchetes introducimos o URL real.

Por fin, lanzamos git push origin master --forcepara enviar o código de WordPress de Pantheon a GitLab.

A opción –force só é necesaria unha vez. Despois en equipos git push non estará en GitLab.

Configurar credenciais e variables

Lembras como engadimos unha clave SSH localmente para iniciar sesión en Pantheon e GitLab? O token SSH pódese usar para autorizar GitLab e Pantheon.

GitLab ten unha excelente documentación. Vexamos sección sobre chaves SSH cando se usa o executor de Docker no documento sobre o uso de chaves SSH con GitLab CI/CD.

Agora completaremos os dous primeiros pasos: Imos crear un novo par de chaves SSH localmente con ssh-keygen e engadir a chave privada como variable ao proxecto.

Despois preguntarémolo SSH_PRIVATE_KEY como Variable de entorno GitLab CI/CD na configuración do proxecto.
No terceiro e cuarto pasos crearemos un ficheiro .gitlab-ci.yml con contido coma 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"

Aínda non cometemos o ficheiro .gitlab-ci.yml, entón terás que engadirlle algo máis.

Agora realizamos o quinto paso e engade a chave pública que creou no primeiro paso aos servizos aos que precisa acceder no entorno de compilación.

No noso caso, queremos acceder a Pantheon desde GitLab. Seguimos as instrucións do documento do Panteón sobre engadindo unha chave SSH a Pantheon e realiza este paso.

Lembra: o SSH privado está en GitLab, o SSH aberto está en Pantheon.

Imos configurar algunhas variables de ambiente máis. O primeiro chámase PANTHEON_SITE. O seu valor é o nome do sitio Panteón na túa máquina.

O nome da máquina aparece ao final do comando Clonar con Git. Xa clonaches o sitio localmente, polo que este será o nome do directorio do repositorio local.

A continuación, configuremos a variable de ambiente PANTHEON_GIT_URL. Este é o URL do repositorio de Git para o sitio de Pantheon que xa usamos.

Introduza só o URL do repositorio SSH, sen git clone e o nome do sitio na máquina ao final.

Uf. Xa está feito, agora podemos rematar o noso arquivo .gitlab-ci.yml.

Crear unha tarefa de implantación

O que faremos inicialmente con GitLab CI é moi similar ao que fixemos cos repositorios Git no pasado. Pero esta vez, engademos o repositorio de Pantheon como unha segunda fonte Git remota e, a continuación, engademos o código de GitLab a Pantheon.

Para iso, imos configurar etapa deploy и tarefa deploy:dev, porque implementaremos no entorno de desenvolvemento en Pantheon. O ficheiro resultante .gitlab-ci.yml terá este aspecto:

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

Variables SSH_PRIVATE_KEY, PANTHEON_SITE и PANTHEON_GIT_URL debería parecer familiar: configuramos estas variables de ambiente antes. Con estas variables poderemos utilizar os valores do ficheiro .gitlab-ci.yml moitas veces, e só terán que actualizarse nun só lugar.

Finalmente, engade, confirma e envía o ficheiro .gitlab-ci.yml en GitLab.

Comprobando a implantación

Se fixemos todo correctamente, a tarefa deploy:dev executarase correctamente en GitLab CI/CD e enviará unha confirmación .gitlab-ci.yml no Panteón. Imos botarlle unha ollada.

Enviando fíos de solicitude de combinación a Pantheon

Aquí usaremos a miña función favorita do Panteón − multidev, onde podes crear ambientes Pantheon adicionais para as sucursais de Git baixo demanda.

O acceso a multidev é limitado, polo que se pode omitir esta sección. Pero se tes acceso, podes aumentar seriamente a produtividade configurando a creación automática de ambientes multidev en Pantheon a partir das solicitudes de combinación de GitLab.

Primeiro imos facer unha nova rama de Git localmente usando git checkout -b multidev-support. Agora imos cambiar algo de novo .gitlab-ci.yml.

Gústame incluír o número de solicitude de combinación no nome do contorno de Pantheon. Por exemplo, a primeira solicitude de combinación é mr-1, segundo - mr-2 etc.

A solicitude de combinación cambia, polo que necesitamos determinar dinámicamente os nomes das ramas do Panteón. É sinxelo en GitLab: só tes que usalo variables de ambiente predefinidas.

Podemos levar $CI_MERGE_REQUEST_IIDpara especificar o número de solicitude de combinación. Apliquemos todo isto xunto coas variables de ambiente globais que especificamos anteriormente e engademos unha nova tarefa deploy:multidev ao final do ficheiro .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á semellante á nosa tarefa deploy:dev, só a rama é enviada ao Panteón, non a master.

Engadimos e confirmamos o ficheiro actualizado .gitlab-ci.yml, e agora imos impulsar unha nova rama a GitLab con git push -u origin multidev-support.

Agora imos crear unha nova solicitude de combinación desde a rama multidev-supportpresionando Crear solicitude de combinación.

Unha vez creada unha solicitude de combinación, observamos como se executa a tarefa CI/CD deploy:multidev.

Mira, enviouse un novo fío ao Panteón. Pero se imos á sección multidev no panel de control do sitio do Panteón, non veremos o novo ambiente alí

Vexamos a sección Git Branches.

Como resultado, o noso fío mr-1 chegou ao Panteón. Imos crear un ambiente a partir dunha rama mr-1.

Creamos un ambiente multidev, agora volvamos a GitLab e vexamos a sección Operacións > Contornas. Veremos entradas para dev и mr-1.

Isto é porque engadimos unha entrada environment Con nome name и url en tarefas de CI/CD. Se facemos clic na icona do entorno aberto, dirixirémonos á URL do entorno multidev en Pantheon.

Automatiza a creación de multidev

En principio, podes parar aquí e lembrar de crear un ambiente multidev para cada solicitude de combinación, pero este proceso pódese automatizar.

Pantheon ten unha ferramenta de liña de comandos Término, onde podes traballar coa plataforma automaticamente. Terminus permítelle crear ambientes multidev desde a liña de comandos, ideal para GitLab CI.

Necesitamos unha nova solicitude de combinación para probar isto. Imos crear unha nova rama usando git checkout -b auto-multidev-creation.

Para usar Terminus nas tarefas de CI/CD de GitLab, necesitas un token de máquina para a autenticación con Terminus e unha imaxe de contedor con Terminus.

Creando un token de máquina Panteón, gárdao nun lugar seguro e engádeo como unha variable de ambiente global en GitLab co nome PANTHEON_MACHINE_TOKEN.

Se esqueceches como engadir variables de ambiente de GitLab, volve a onde definimos PANTHEON_SITE.

Creando un Dockerfile con Terminus

Se non usa Docker ou non lle gustan os ficheiros Dockerfile, toma a miña imaxe registry.gitlab.com/ataylorme/pantheon-gitlab-blog-demo:latest e omita esta sección.

GitLab ten un rexistro de contedores, onde podemos construír e colocar o Dockerfile para o noso proxecto. Imos crear un Dockerfile con Terminus para traballar con Pantheon.

Terminus é unha ferramenta de liña de comandos PHP, entón imos comezar coa imaxe PHP. Estou instalando Terminus a través de Composer, así que usarei imaxe oficial de Docker Composer. Nós creamos Dockerfile no directorio do repositorio local co seguinte contido:

# 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 instrucións para montar e enviar imaxes da sección Construír e impulsar imaxes в documentación de rexistro de contedorespara recoller unha imaxe Dockerfile e empúxao a GitLab.

Abre a sección Rexistro no proxecto GitLab. Se todo saíu segundo o previsto, a nosa imaxe estará aí. Anote unha ligazón á etiqueta da imaxe: necesímola para o ficheiro .gitlab-ci.yml.

Sección script no problema deploy:multidev comeza a crecer, así que movémolo a un ficheiro separado. Crea un ficheiro novo 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á nun directorio privado e non permite o acceso web a Pantheon. Temos un script para a nosa lóxica multidev. Imos agora actualizar a sección deploy:multidev arquivo .gitlab-ci.ymlpara que resulte así:

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

Debemos asegurarnos de que as nosas tarefas se realizan na imaxe personalizada creada, así que imos engadir unha definición image dende o URL do rexistro ata .gitlab-ci.yml. Como resultado, acabamos cun ficheiro coma 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

Engadir, comprometer e enviar private/multidev-deploy.sh и .gitlab-ci.yml. Agora volvemos a GitLab e agardamos a que se complete a tarefa CI/CD. Ten paciencia: o multidev pode tardar varios minutos en crearse.

Despois imos mirar a lista multidev en Pantheon. Ai milagre! Entorno multidev mr-2 xa aquí.

Conclusión

O meu equipo divertiuse moito máis cando comezamos a abrir solicitudes de combinación e a crear ambientes automaticamente.

Coas poderosas ferramentas de GitLab e Pantheon, podes conectar GitLab a Pantheon automaticamente.

Xa que usamos GitLab CI/CD, o noso fluxo de traballo terá espazo para crecer. Aquí tes un par de ideas para comezar:

• Engade un paso de compilación.
• Engade probas automatizadas.
• Engade unha tarefa para garantir que se cumpren os estándares do código.
• Engadir probas dinámicas de seguridade das aplicacións.

Fainos saber o que pensas sobre GitLab, Pantheon e a automatización.

PS Sabías que Terminus, a ferramenta de liña de comandos de Pantheon, pódese ampliar mediante complementos?

En Pantheon fixemos un bo traballo na versión 2 do noso complemento para as ferramentas de construción de Terminus co soporte de GitLab. Se non queres molestarte coa configuración de cada proxecto, proba este complemento e axúdanos a probar a versión beta v2. Para o equipo Terminus build:project:create Só necesitas un token Pantheon e un token GitLab. Implementará un dos proxectos de mostra con Composer e probas automatizadas, creará un novo proxecto en GitLab, un novo sitio de Pantheon, e conectaraos mediante variables de ambiente e chaves SSH.

Sobre o autor

Andrew Taylor crea ferramentas para desenvolvedores en Panteón.

Fonte: www.habr.com