Un artículo para comprender la implementación automatizada en contenedores (git + jenkins + harbour + kubernetes)

1. ¿Qué es la implementación automática de contenedores?

  En pocas palabras, solo necesitamos hacer clic (o activar a través de un gancho de gitlab), y el código completará automáticamente la compilación -> generación de imágenes -> implementación en contenedor. En comparación con la implementación tradicional, puede ahorrar muchos pasos, lo que es especialmente adecuado para proyectos de desarrollo ágiles con cambios frecuentes (de hecho, es mejor utilizar la automatización para proyectos de implementación en contenedores, que es bastante libre de problemas).
  Este artículo trata principalmente sobre la comprensión y el uso de cada componente, los pasos de instalación específicos no se ampliarán. Es una comprensión simple de las personas, espero que puedan corregirme.
  La siguiente figura es el diagrama de flujo y las herramientas utilizadas para la implementación automatizada de contenedores.

2. ¿Qué es Jenkins?

  Jenkins es una herramienta de integración continua (CI) de código abierto que proporciona una interfaz de operación amigable.Se usa principalmente para construir / probar proyectos de software de manera continua y automática y monitorear la operación de tareas externas. En pocas palabras, es responsable de todo el proceso de nuestra implementación automatizada. Ya sea que esté creando o produciendo imágenes, o implementando, está controlado por él. Puede completar automáticamente muchas cosas a través de diferentes configuraciones.
  Las herramientas de control de versiones de uso común de Jenkins incluyen SVN y GIT, y las herramientas de compilación de uso común incluyen Maven, Ant y Gradle.

3. ¿Qué es mirror y dockerfile?

  Los proyectos tradicionales, como los paquetes jar, deben colocarse en el host para ejecutar java -jar, como los paquetes war, deben colocarse en el host, se instala un tomcat y luego startup.sh inicia la ejecución de tomcat. Una desventaja de estas implementaciones tradicionales es que el entorno y los paquetes de implementación están separados. Versiones como JDK y tomcat están fijas en el host. Si queremos migrar a un nuevo host, debemos instalar el nuevo entorno y asegurarnos de que la versión del el entorno es coherente., lo que es problemático y propenso a errores, lo que lleva a fallas de implementación.
  Entonces, la imagen de Docker nació, en realidad es equivalente a un paquete de implementación ejecutable y al entorno en el que se ejecuta el paquete de implementación, el sistema operativo, los parámetros de configuración y otras cosas que se necesitan en tiempo de ejecución. La imagen se puede iniciar y ejecutar en cualquier host, y el entorno permanece constante, lo que resuelve algunos de los puntos débiles de la implementación tradicional. El contenedor es en realidad equivalente a una imagen en ejecución.
  Dockerfile es un archivo que describe cómo se genera la imagen. Generalmente contiene la imagen básica (como el sistema operativo o tomcat, etc.), parámetros de inicio y comandos de inicio.

4. ¿Qué es el puerto?

  Harbour es el almacén de espejos, que puede acceder al espejo. Kubernetes puede extraer el espejo a través del comando docker pull mirror warehouse / nombre del proyecto / nombre del espejo: etiqueta, y jenkins puede empujar el espejo construido al almacén espejo. Otros almacenes espejo de uso común incluyen Docker Hub, etc.

5. ¿Qué son los kubernetes y rancher?

  Kubernetes es una plataforma de código abierto portátil y extensible para administrar cargas de trabajo y servicios en contenedores, que puede promover la configuración declarativa y la automatización, lo que se conoce como k8s para abreviar. En pocas palabras, es una herramienta que puede realizar la orquestación de contenedores y realizar la operación, el mantenimiento y la administración automáticos del contenedor. Como se mencionó anteriormente, el contenedor es la imagen en ejecución. La imagen es la unidad desplegable que contiene el entorno. El contenedor no es suficiente para Se necesitan funciones como equilibrio de carga, descubrimiento de servicios, verificación de estado, reinicio fallido, etc. k8s es una de estas plataformas.
  Rancher es una plataforma de gestión de contenedores de nivel empresarial de código abierto. Contiene kubernetes, que es la capa superior de la herramienta de orquestación de contenedores. K8s tiene funciones de administración de contenedores muy poderosas, pero debido a que se administra a través de la línea de comandos, la capacidad de visualización visual es relativamente pobre. Rancher tiene una interfaz de usuario, a través de la cual se pueden ejecutar convenientemente varias funciones de k8s, y se pueden agregar varias funciones como recopilación de registros, administración de clústeres multi-k8s y monitoreo. Puede considerarse una versión mejorada de k8s.

6. Iniciar configuración

1. Primero crea un proyecto jenkins

  La primera es la descripción del proyecto. Descartar compilaciones antiguas es descartar compilaciones antiguas. Generalmente, se recomienda configurar (porque cada proyecto se compila en un momento de varios cientos de mb y la presión del disco es alta). Los días para mantener las compilaciones son para guardar las compilaciones en unos pocos días, el número máximo de compilaciones a conservar es el número máximo de compilaciones.

2. Configurar git

  Configure la URL para que gitlab extraiga el código. Tenga en cuenta que si aparece en rojo, generalmente se debe a una falla en la red o credenciales incorrectas. La autenticación fallida significa que las credenciales son incorrectas. Después de hacer clic en Agregar, puede ingresar la contraseña de la cuenta de gitlab para configurar una credencial.

3. Gancho de configuración

  Permítanme mencionar que el gancho es webhook, que es para proporcionar una interfaz a gitlab y permitir que envíe eventos para decirle a jenkins que inicie la implementación automatizada.

  Marque Compilar cuando se envíe un cambio a GitLab. URL del webhook de GitLab, haga clic en la opción avanzada, luego genere la clave y podrá configurar el gancho en gitlab con la URL y la clave.

  Ingrese al proyecto de gitlab, haga clic en configuración a la izquierda para ingresar a la página de configuración del gancho, complete la URL y la clave obtenida por jenkins, marque Trigger y haga clic en guardar, y el gancho está configurado. Cabe señalar que los eventos de inserción activan el gancho cada vez que se inserta el código, y el evento de inserción de etiqueta activa el gancho solo para las inserciones de etiquetas. En términos generales, la inserción de etiquetas se selecciona para evitar construcciones demasiado frecuentes, y la etiqueta se puede usar como una etiqueta de espejo al mismo tiempo Distingue las imágenes que se construyen cada vez.

4. Creación de configuración y generación de imágenes

#!/bin/bash
#harbor环境变量配置
export REGISTRY=harbor域名
export PROJECT=harbor项目名
export BUILD_IMAGE_NAME=镜像名称
#git_tag_name是gitlab钩子推送时的标签，一般也用来作为镜像的标签
export BUILD_IMAGE_TAG=${
    
    GIT_TAG_NAME}
export HORBOR_USERNAME=harbor账号
export HORBOR_PASSWORD=harbor密码
#镜像名称
export IMAGE_ADDRESS=${
    
    REGISTRY}/${
    
    PROJECT}/${
    
    BUILD_IMAGE_NAME}:${
    
    BUILD_IMAGE_TAG}

#根据Dockerfile制作镜像，并推送镜像到harbor
#开启docker服务
service docker start
#登录镜像仓库
docker login ${
    
    REGISTRY} -u ${
    
    HORBOR_USERNAME} -p ${
    
    HORBOR_PASSWORD}
#根据-f指定dockerfile，并根据dockerfile打包镜像，-t指定镜像名称
docker build -f ${
    
    WORKSPACE}/scripts/apollo-on-kubernetes/apollo-portal-server/Dockerfile -t ${
    
    IMAGE_ADDRESS} .
#镜像推送至仓库
docker push ${
    
    IMAGE_ADDRESS}
#删除镜像（为了减轻jenkins磁盘压力）
docker rmi -f  ${
    
    IMAGE_ADDRESS}

  Haga clic en agregar paso de publicación y seleccione ejecutar shell para ejecutar el script de shell para empaquetar la imagen.

5. Configurar la inserción de k8s

  Jenkins necesita complementos para admitir k8s. Por lo general, existen los siguientes tipos:
  Complemento Kubernetes Cli : el complemento se puede operar directamente en Jenkins mediante la línea de comandos de kubernetes.
  Complemento de Kubernetes : para usar kubernetes, debe instalar el complemento.
  Complemento de implementación continua de Kubernetes : el complemento de implementación de Kubernetes se puede usar según sea necesario.
  Ingrese la configuración de jenkins haciendo clic en Administrar jenkins y luego haga clic en administrar complementos para realizar el complemento. La mayoría de los complementos se pueden buscar e instalar directamente. No es compatible, también puede descargar el complemento a través del sitio web del complemento, como https://mirrors.tuna.tsinghua.edu.cn/jenkins/ (espejo de la Universidad de Tsinghua ) o el sitio web oficial https://plugins.jenkins.io/ y luego instale el complemento.
  Luego haga clic en agregar paso de publicación y seleccione implementar en kubernetes (se requiere compatibilidad con complementos).

  Si no hay ningún certificado, debe obtener el archivo de configuración de kubernetes del clúster de kubernetes, hacer clic en el clúster y luego hacer clic en el archivo kubeconfig y luego copiar el contenido.


  Haga clic en agregar en la credencial de jenkins, seleccione kubeconfig para el tipo, marque ingresar directamente, pegue el contenido de kubeconfig previamente copiado en el contenido, ingrese la identificación y la descripción para una fácil identificación y luego guarde.

  En este punto, la configuración de jenkins está completa. Puede automatizar la implementación de contenedores con un clic enganchando o haciendo clic en Construir ahora.
  Nota : Primero debes crear los espacios de nombres y los proyectos correspondientes en los clústeres harbour y k8s. Puedes consultar el siguiente ejemplo para el archivo yaml, o implementar manualmente el servicio en Rancher, exportar el yaml y eliminar algunos parámetros de ID únicos y de tiempo. .

Ejemplo de Seven. Dockerfile

Ejemplo de proyecto general springBoot

# 基础镜像，这里一般是基础操作系统镜像（带JDK的centos之类）
FROM xxxxx/xxxx/docker-base-os-centos-jdk8:1.0.0
# 时区
ENV TZ Asia/Shanghai
# 将原项目的jar复制过来改个名字
ADD ${
    
    WORKSPACE}/src/webapp/target/webapp-1.0.0.jar server.jar
# 启动命令
ENTRYPOINT ["java","-jar","-Xms4000m","-Xmx4000m","-Xss256k","-Xmn200m","/server.jar"]

Ejemplo de proyecto tomcat

# 基础镜像，这里是tomcat基础镜像，地址从镜像仓库获取
FROM xxxxx/xxxx//tomcat
# 时区
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
#将webapp下的文件全部删除
RUN rm -rf /usr/local/tomcat/webapps/*
#将target下的xx.war拷贝到/usr/local/tomcat/webapps/下
ADD ./src/target/javafw-1.0.war /usr/local/tomcat/webapps/ROOT.war
#端口
EXPOSE 8080
#设置启动命令
ENTRYPOINT ["/usr/local/tomcat/bin/catalina.sh","run"]

8. ejemplo de archivo yaml

Configuración de carga de trabajo de muestra, deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    workload.user.cattle.io/workloadselector: deployment-web-admin-web
  name: admin-web
  namespace: web
spec:
  replicas: 1
  selector:
    matchLabels:
      workload.user.cattle.io/workloadselector: deployment-uac-web-admin-web
  strategy:
    rollingUpdate:
      maxSurge: 0
      maxUnavailable: 25%
    type: RollingUpdate
  template:
    metadata:
      labels:
        workload.user.cattle.io/workloadselector: deployment-web-admin-web
    spec:
      containers:
      - args:
        - --spring.profiles.active=test
# 镜像名，注意，git_tag_name为jenkins从gitlab获取的推送时的标签
        image: XXXXXXXXX/XXXXX/image-name:${
    
    GIT_TAG_NAME}
        imagePullPolicy: Always
        name: admin-web
        ports:
#容器端口
        - containerPort: 8081
          name: web-8081
          protocol: TCP
      restartPolicy: Always

Servicio de clúster (para acceder dentro del clúster), clusterlp-service.yaml:

# 对内暴露的端口
apiVersion: v1
kind: Service
metadata:
  annotations:
    field.cattle.io/targetWorkloadIds: '["deployment:web:admin-web"]'  # 配置命名空间和工作负载
  name: admin-web
  namespace: web
spec:
  ports:
  - name: web-8081-admin-web
    port: 8081
    protocol: TCP
    targetPort: 8081
  selector:
    workload.user.cattle.io/workloadselector: uac-web-admin-web
  type: ClusterIP

Servicio público, exposición de puertos (para acceso externo al clúster), nodeport-service.yaml:

# 对外暴露的端口
apiVersion: v1
kind: Service
metadata:
  annotations:
    field.cattle.io/targetWorkloadIds: '["deployment:web:admin-web"]'    # 配置命名空间和工作负载
  name: admin-web-nodeport
  namespace: web
spec:
  ports:
  - name: uac-web-8081
#对外暴露的端口
    nodePort: 8555
#容器内部端口
    port: 8081
    protocol: TCP
    targetPort: 8081
  selector:
    workload.user.cattle.io/workloadselector: deployment-web-admin-web
  type: NodePort

IX. Registro de problemas comunes

Generalmente, cuando falla la compilación, puede hacer clic en compilación única y hacer clic en salida de la consola para ver el registro de compilación y el motivo de la falla.

1. jenkins 用 spring-boot-maven-plugin 构建 出错 ： falló el reempaquetado: no se pudo encontrar la clase principal
   https://blog.csdn.net/qq_35530005/article/details/109333356