Configuración de GitLab Container Registry, CI Pipeline con SonarQube

IEn el tutorial de hoy, usaremos el registro de contenedores de GitLab para almacenar imágenes. Consulte nuestra guía de GitLab para la instalación y configuración de GitLab.

Comencemos con la instalación del contenedor primero.

1. Configurar Container Registry

Navegue al área de administración, y lo primero que notará es que el registro del contenedor está desactivado de forma predeterminada.

Instalar el registro de contenedores

Deberíamos modificar el archivo de configuración de GitLab. Ingrese el siguiente comando:

a) Modificar gitlab.rb

vim /etc/gitlab/gitlab.rb

Cambie la siguiente línea:

registry_external_url 'https://gitlab.fosslinux.com:5050'

Ahora la URL del registro está escuchando en HTTPS bajo la URL de GitLab existente con un puerto diferente.

b) Después de la modificación, debe volver a configurar Gitlab.

gitlab-ctl reconfigure

Una vez hecho esto, vaya al área de administración, y esta vez, debería verlo habilitado.

c) Pruebe el inicio de sesión del contenedor desde una máquina diferente. Sin embargo, tenga en cuenta que Docker debe instalarse en ese sistema.

docker login gitlab.fosslinux.com:5050

Inicio de sesión en Docker

La ubicación predeterminada de la tienda de imágenes es la siguiente:

/var/opt/gitlab/gitlab-rails/shared/registry

Si desea cambiar la ruta, use VIM para editarla.

vim /etc/gitlab/gitlab.rb

Cambie la siguiente línea:

gitlab_rails['registry_path'] = "/path/to/registry/storage"

Luego reconfigura.

gitlab-ctl reconfigure

2. Creación de un proyecto

Crearemos un nuevo proyecto para una tubería. Para hacer eso, vaya al Área de administración.

Debería ver un área de administración similar a esta:

Área de administración

Luego haga clic en New Group.

Puedes darle cualquier nombre a tu grupo. Luego, escriba un nombre para la URL del proyecto. El nivel de visibilidad es "Privado" aquí; Creamos un grupo llamado "gitdemo".

Luego, nuevamente Vaya al Área de administración -> Nuevo proyecto

Dale un nombre al proyecto. Seleccione el grupo creado previamente para el proyecto.

Después de crear un proyecto, puede agregar un archivo de muestra al repositorio.

3. Habilite el registro de contenedores para el proyecto.

Ir a Configuración del proyecto -> General y luego expandir Visibilidad, funciones del proyecto, permisos.

Luego habilite el Registro de contenedores.

Ahora vaya a su proyecto y podrá ver el registro de contenedores en la sección de paquetes.

4. Deshabilitar AutoDevops

Ir a tu proyecto -> Ajustes -> CICD

Desactivar devoluciones automáticas — Deshabilitar Auto DevOps

Luego expande DevOps automático y deselecciona "Predeterminado para la canalización de Auto DevOps ".

5. Cree una clave SSH desde la máquina cliente / desarrollador

Aquí vamos a crear una clave ssh y autenticarnos con nuestro GitLab. Después de eso, podemos empujar, extraer y clonar repositorios de git desde nuestra máquina cliente.

a) Ejecute el siguiente comando para generar la clave:

ssh-keygen -t rsa -b 4096 -C "darshana@fosslinux.com"

b) Copiar clave pública:

cat ~/.ssh/is_rsa_pub

Ahora inicie sesión en el servidor de GitLab. Vaya a Perfil -> Llaves SSH

c) Agregue la clave copiada a la sección de claves y guarde.

d) Ahora necesitamos obtener la URL para clonar el repositorio usando SSH.

Ve a tu proyecto -> Clon.

Copie el clon con la URL ssh.

Antes de clonar el repositorio en nuestra máquina, necesitamos instalar "git"

Instale git en cliente-servidor:

yum install git -y

Ahora vamos a clonar el repositorio y enviar nuestro código al repositorio de Gitlab.

Configuración global de Git

git config --global user.name "Darshana"

git config --global user.email "darshana@fosslinux.com"

Ejecute el siguiente comando para clonar el repositorio:

git clone git@git.fosslinuxcom:gitdemo/fosslinux.git

Copie su código fuente en la carpeta clonada.

Vaya a la carpeta clonada:

cd fosslinux

Ahora envíe el código al repositorio:

git add .

git status

git commit -m "demo Project files"

git push

6. Instale GitLab Runner

Se recomienda instalar GitLab Runner en un servidor separado de donde está instalado GitLab. También puede instalarlo en el mismo servidor, si aún lo desea de esa manera.

Aquí vamos a utilizar el ejecutor de Docker; por lo tanto, debemos instalar Docker antes de usar Runner.

a) El ejecutor de Docker

GitLab Runner puede usar Docker para ejecutar trabajos en imágenes proporcionadas por el usuario debido al uso del ejecutor de Docker.

El ejecutor de Docker, cuando se usa con GitLab CI, se conecta a Docker Engine y ejecuta cada compilación en un contenedor aislado usando la imagen predefinida que está configurada en el archivo Gitlab CI. Veremos el archivo Gitlab CI cuando analicemos la canalización.

Instalar repositorio:

curl -L https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.deb.sh | bash

Instalar Runner:

apt-get install gitlab-runner

Verificar el estado del corredor:

gitlab-runner status

Registrar corredor

Aquí vamos a agregar un Runner compartido. Vaya al Área de administración -> Corredores.

Entonces puedes ver Configurar un corredor compartido manualmente sección. Necesitamos nuestra URL de Gitlab y el token para el corredor registrado.

Ejecutar Register Runner

Ejecute el siguiente comando para registrar el corredor.

gitlab-runner register

Debería hacer algunas preguntas. Responde las siguientes preguntas.

a) Ingrese la URL de su instancia de GitLab:

Please enter the gitlab-ci coordinator URL (e.g. https://gitlab.com )
https://gitlab.fosslinux.com

b) Ingresa el token que obtuviste para registrar al Runner:

Please enter the gitlab-ci token for this runner
xxxxxxxxxxxxxxxxxxxxxxx

c) Ingrese una descripción para el corredor; puede cambiar esto más tarde en la interfaz de usuario de GitLab:

Please enter the gitlab-ci description for this runner
[hostname] Docker-runner

d) Ingrese las etiquetas asociadas con el corredor; puede cambiar esto más tarde en la interfaz de usuario de GitLab:

Please enter the gitlab-ci tags for this runner (comma separated):
master,dev,qa

e) Ingrese el ejecutor del corredor:

Please enter the executor: ssh, docker+machine, docker-ssh+machine, kubernetes, docker, parallels, virtualbox, docker-ssh, shell:
docker

f) Si elige Docker como su ejecutor, se le pedirá que la imagen predeterminada se use para proyectos que no definen una en .gitlab-ci.yml:

Please enter the Docker image (eg. ruby:2.6):
alpine:latest

Ahora Runner se registró con éxito.

Reiniciar Runner

gitlab-runner restart

Ahora actualice la página Corredores (Área de administración -> Corredores). Puede ver el corredor recién agregado.

Necesitamos modificar algunas configuraciones para el Runner. Así que haz clic en el token.

Luego, seleccione "Ejecutar trabajos sin etiquetar" y guarde los cambios.

Cambiar las configuraciones del corredor de Gitlab

Vamos a usar docker-in-docker (dind) modo en la canalización de GitLab, así que tenemos que usar privilegiado = verdadero en nuestros contenedores Docker. Por tanto, vamos a habilitar el modo privilegiado.

Editar archivo de configuración:

vim /etc/gitlab-runner/config.toml

Cambie la sección "privilegiados".

privileged = true

Después de la modificación, puede ver un archivo similar a este.

Luego reinicia Runner.

gitlab-runner restart

7. Configurar variables para GitLab PipeLine

Agregar variables de registro de contenedor

Haga clic en proyecto -> Configuración -> CICD -> Variables (haga clic en Expandir).

Agregue lo siguiente a la clave y agregue valor.

CI_REGISTRY_USER

CI_REGISTRY_PASSWORD

Aquí debe agregar el nombre de usuario y la contraseña de GitLab.

Integrar con SonarQube Server

Obtenga el token de SonarQube y agréguelo a GitLab. Inicie sesión en el servidor SonarQube.

Vaya a Administración> haga clic en Seguridad> Usuarios> Haga clic en Tokens

Debería abrir una ventana simbólica.

Genere token con cualquier nombre -> Copie el token.

Copie el token y vuelva a GitLab. Haga clic en proyecto -> Configuración -> CICD -> Variables

Agrega una nueva variable.

SONARQUBE_TOKEN

Pega el token de la sonda en el valor "SONARQUBE_TOKEN".

8. Cree una canalización

Los siguientes archivos deben estar en la carpeta del repositorio

a) Dockerfile

Necesitamos un archivo docker para construir nuestra imagen. Siga nuestra guía de archivos de Docker.

Aquí está nuestro archivo de Docker:

FROM ddarshana/alpinenode10

ENV NODE_ENV=production
RUN apk add --update curl && rm -rf /var/cache/apk/*
RUN mkdir /app
WORKDIR /app

COPY package.json .

RUN npm install
COPY . .

CMD ["npm", "start"]

Vaya a su proyecto y cree un nuevo archivo llamado "Archivo Docker".

b) Agregar sonar-project.properties

El archivo de propiedades de la sonda debe estar en nuestro directorio raíz de código fuente para enviar datos de escaneo al servidor SonarQube.

Aquí está nuestro archivo:

# Required metadata
sonar.projectKey=fosslinux
sonar.projectName=fosslinux

# Comma-separated paths to directories with sources (required)
sonar.sources=./

# Language
sonar.language=js
sonar.profile=node
# Encoding of sources files
sonar.sourceEncoding=UTF-8

Ve a tu proyecto y crea "sonar-project.properties".

I. Crear un archivo GitLab-CI

Vaya a su proyecto y cree un archivo llamado ".gitlab-ci.yml".

Este es nuestro archivo.

stages:
- Lint images
- Codequality
- Build and publish images

variables:
DOCKER_REGISTRY: gitlab.fosslinux.com:5050
APP_NAME: fosslinux

linting:
stage: Lint images
image: node:4-alpine
only: 
- master
script:
- npm install -g dockerlint && npm cache clean
- find ./ -name Dockerfile -exec dockerlint {} ;

codequality:
stage: Codequality
image: ddarshana/alpine-sonarscanner
script:
- sonar-scanner -Dsonar.host.url=https://sonar.fosslinux.com -Dsonar.login=$SONARQUBE_TOKEN -Dsonar.projectVersion=$CI_PIPELINE_ID -Dsonar.projectName=$CI_PROJECT_NAME+$CI_BUILD_REF_NAME
only: 
- master

publishing:
stage: Build and publish images 
image: docker:18.09.7
services:
- docker:18.09.7-dind
only: 
- master

script:

- docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $DOCKER_REGISTRY
- docker build . -t $DOCKER_REGISTRY/gitdemo/$APP_NAME:$CI_PIPELINE_ID
- docker push $DOCKER_REGISTRY/gitdemo/$APP_NAME:$CI_PIPELINE_ID
- echo "pushed image $APP_NAME:$CI_PIPELINE_ID"
- docker logout $DOCKER_REGISTRY

Aquí hemos definido tres etapas para nuestro Pipeline:

stages: 
- Lint images 
- Codequality 
- Build and publish images

Las variables se establecen para el registro de la ventana acoplable y el nombre de la aplicación.

variables: 
DOCKER_REGISTRY: gitlab.fosslinux.com:5050 
APP_NAME: fosslinux

Una vez que confirme los cambios en la rama maestra, la canalización debería comenzar.

Como puede ver, Pipeline se está ejecutando. Puede ver las etapas del Pipeline.

Si todas las etapas son un éxito, puede ver el resultado de la siguiente manera.

Puede hacer clic en cualquier etapa y ver sus registros.

a) Consultar el registro de contenedores.

Proyecto -> Paquetes -> registro de contenedores

Entonces puedes ver nuestra imagen.

b) Verificar informe de Sonar

Inicie sesión en SonarQube y podrá ver el informe de nuestro proyecto.

Se trata de crear una canalización de GitLab con el servicio de contenedores de GitLab y la integración de Sonarqube.

Deja una respuesta Cancelar la respuesta