Phenquestions
En 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:
registration_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.
reconfigurar gitlab-ctl
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
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 ['ruta_registro'] = "/ ruta / al / registro / almacenamiento"
Luego reconfigura.
reconfigurar gitlab-ctl
2. Creando 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:
Luego haga clic en el nuevo grupo.
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
Dar un nombre para el proyecto. Seleccione el grupo creado previamente para el proyecto.
Después de crear un proyecto, puede agregar un archivo de muestra al repositorio.
3. Habilitar el registro de contenedores para el proyecto
Ir 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
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:
gato ~ /.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.
Copiar clon con 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: usuario global.nombre "Darshana"
git config: usuario global.correo electrónico "darshana @ fosslinux.com "
Ejecute el siguiente comando para clonar el repositorio:
git clon git @ git.fosslinuxcom: gitdemo / fosslinux.git
Copie su código fuente a la carpeta clonada.
Vaya a la carpeta clonada:
cd fosslinux
Ahora envíe el código al repositorio:
git agregar .
estado de git
git commit -m "archivos de proyecto de demostración"
git push
6. Instalar 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: // paquetes.gitlab.com / install / repositories / runner / gitlab-runner / script.debutante.sh | intento
Instalar Runner:
apt-get install gitlab-runner
Verificar el estado del corredor:
estado de gitlab-runner
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.
registro gitlab-runner
Debería hacer algunas preguntas. Responde las siguientes preguntas.
a) Ingrese la URL de su instancia de GitLab:
Ingrese la URL del coordinador de gitlab-ci (e.gramo. https: // gitlab.com) https: // gitlab.Fosslinux.com
b) Ingresa el token que obtuviste para registrar al Runner:
Ingrese el token de gitlab-ci para este corredor xxxxxxxxxxxxxxxxxxxxxxx
c) Ingrese una descripción para el corredor; puede cambiar esto más tarde en la interfaz de usuario de GitLab:
Ingrese la descripción de gitlab-ci para este corredor [nombre de host] Docker-runner
d) Ingrese las etiquetas asociadas con el corredor; puede cambiar esto más tarde en la interfaz de usuario de GitLab:
Ingrese las etiquetas gitlab-ci para este corredor (separadas por comas): master, dev, qa
e) Ingrese el ejecutor del corredor:
Ingrese el ejecutor: ssh, docker + máquina, docker-ssh + máquina, kubernetes, docker, paralelos, virtualbox, docker-ssh, shell: docker
f) Si elige Docker como su ejecutor, se le pedirá que utilice la imagen predeterminada para proyectos que no definen una .gitlab-ci.yml:
Introduzca la imagen de Docker (p. Ej. rubí: 2.6): alpino: último
Ahora Runner se registró con éxito.
Reiniciar Runner
reiniciar gitlab-runner
Ahora actualice la página Corredores (Área de administración -> Corredores). Puedes 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 lo tanto, vamos a habilitar el modo privilegiado.
Editar archivo de configuración:
vim / etc / gitlab-runner / config.toml
Cambiar la sección "privilegiados".
privilegiado = verdadero
Después de la modificación, puede ver un archivo similar a este.
Luego reinicia Runner.
reiniciar gitlab-runner
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. Iniciar 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
Agregar una nueva variable.
SONARQUBE_TOKEN
Pega el token de la sonda en el valor "SONARQUBE_TOKEN".
8. Crear 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 . EJECUTAR npm install COPY… CMD ["npm", "start"]
Vaya a su proyecto y cree un nuevo archivo llamado "Docker File."
b) Agregar proyecto de sonar.propiedades
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:
# Sonda de metadatos requerida.projectKey = sonar fosslinux.projectName = fosslinux # Rutas separadas por comas a directorios con fuentes (requerido) sonar.fuentes =./ # Sonda de idioma.language = js sonar.profile = node # Codificación de archivos fuente sonar.sourceEncoding = UTF-8
Ve a tu proyecto y crea "sonar-project.propiedades."
I. Crea un archivo GitLab-CI
Vaya a su proyecto y cree un archivo llamado ".gitlab-ci.yml."
Este es nuestro archivo.
etapas: - Imágenes de pelusa - Calidad de código - Variables de creación y publicación de imágenes: 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 imagen: ddarshana / alpine-sonarscanner script: - sonar-scanner -Dsonar.anfitrión.url = https: // sonar.Fosslinux.com -Dsonar.login = $ SONARQUBE_TOKEN -Dsonar.projectVersion = $ CI_PIPELINE_ID -Dsonar.projectName = $ CI_PROJECT_NAME + $ CI_BUILD_REF_NAME solamente: - publicación maestra: etapa: Crear y publicar imágenes image: docker: 18.09.7 servicios: - estibador: 18.09.Solo 7-dind: - script maestro: - inicio de sesión de docker -u $ CI_REGISTRY_USER -p $ CI_REGISTRY_PASSWORD $ DOCKER_REGISTRY - compilación de docker . -t $ DOCKER_REGISTRY / gitdemo / $ APP_NAME: $ CI_PIPELINE_ID - docker push $ DOCKER_REGISTRY / gitdemo / $ APP_NAME: $ CI_PIPELINE_ID - echo "imagen insertada $ APP_NAME: $ CI_PIPELINE_ID" - docker logout $ DOCKER_REGISTRY
Aquí hemos definido tres etapas para nuestro Pipeline:
etapas: - Imágenes de pelusa - Calidad de código - Creación y publicación de imágenes
Las variables se establecen para el registro de Docker 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. Puedes 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.
