Un article pour comprendre le déploiement conteneurisé automatisé (git + jenkins + port + kubernetes)

1. Qu'est-ce que le déploiement automatisé de conteneurs

  En termes simples, il suffit de cliquer (ou de déclencher via un hook gitlab), et le code terminera automatiquement la construction -> génération d'image -> déploiement conteneurisé. Par rapport au déploiement traditionnel, il peut économiser de nombreuses étapes, ce qui est particulièrement adapté aux projets de développement agile avec des changements fréquents (en fait, il est préférable d'utiliser l'automatisation pour les projets de déploiement en conteneur, ce qui est assez simple).
  Cet article porte principalement sur la compréhension et l'utilisation de chaque composant, les étapes d'installation spécifiques ne seront pas développées. C'est une simple compréhension des individus, j'espère que vous pourrez me corriger.
  La figure suivante est l'organigramme et les outils utilisés pour le déploiement automatisé de conteneurs.

2. Qu'est-ce que Jenkins

  Jenkins est un outil d'intégration continue (CI) open source qui fournit une interface de fonctionnement conviviale.Il est principalement utilisé pour construire / tester en continu et automatiquement des projets logiciels et surveiller le fonctionnement des tâches externes. En termes simples, il est responsable de l'ensemble du processus de notre déploiement automatisé. Qu'il s'agisse de créer ou de produire des images, ou de déployer, il est contrôlé par lui. Il peut effectuer automatiquement de nombreuses choses à travers différentes configurations.
  Les outils de contrôle de version couramment utilisés de Jenkins incluent SVN et GIT, et les outils de construction couramment utilisés incluent Maven, Ant et Gradle.

3. Qu'est-ce que le miroir et le fichier docker

  Les projets traditionnels, tels que les packages jar, doivent être placés sur l'hôte pour exécuter java -jar, tels que les packages war, doivent être placés sur l'hôte, un tomcat est installé, puis startup.sh lance tomcat pour s'exécuter. L’un des inconvénients de ces déploiements traditionnels est que l’environnement et les packages de déploiement sont séparés. Des versions telles que JDK et tomcat sont fixées sur l’hôte. Si nous voulons migrer vers un nouvel hôte, nous devons installer le nouvel environnement et nous assurer que la version du l'environnement est cohérent., Ce qui est à la fois gênant et sujet aux erreurs, entraînant des échecs de déploiement.
  Ainsi, l'image Docker a vu le jour, elle équivaut en fait à un package de déploiement exécutable et à l'environnement dans lequel le package de déploiement s'exécute, au système d'exploitation, aux paramètres de configuration et à d'autres éléments nécessaires à l'exécution. L'image peut être démarrée et exécutée sur n'importe quel hôte, et l'environnement reste cohérent, ce qui résout certains des problèmes du déploiement traditionnel. Le conteneur est en fait équivalent à une image en cours d'exécution.
  Dockerfile est un fichier qui décrit la manière dont l'image est générée. Il contient généralement l'image de base (comme le système d'exploitation ou le tomcat, etc.), les paramètres de démarrage et les commandes de démarrage.

4. Qu'est-ce que le port

  Le port est l'entrepôt de miroirs, qui peut accéder au miroir. Kubernetes peut extraire le miroir via la commande docker pull mirror entrepôt / nom du projet / nom du miroir: tag, et jenkins peut pousser le miroir construit vers l'entrepôt miroir. D'autres entrepôts de miroirs couramment utilisés incluent le hub Docker, etc.

5. Que sont kubernetes et rancher

  Kubernetes est une plate-forme open source portable et extensible pour la gestion des charges de travail et des services conteneurisés, qui peut promouvoir la configuration et l'automatisation déclaratives, appelées k8 en abrégé. En termes simples, il s'agit d'un outil qui peut effectuer l'orchestration des conteneurs et réaliser l'opération, la maintenance et la gestion automatiques des conteneurs. Comme mentionné ci-dessus, le conteneur est l'image en cours d'exécution. L'image est l'unité déployable qui contient l'environnement. Le conteneur ne suffit pas pour Des fonctions telles que l'équilibrage de charge, la découverte de services, la vérification de l'état, l'échec du redémarrage, etc. sont nécessaires. k8s est une telle plate-forme.
  Rancher est une plateforme de gestion de conteneurs open source au niveau de l'entreprise. Il contient kubernetes, qui est la couche supérieure de l'outil d'orchestration de conteneurs. K8s a des fonctions de gestion de conteneurs très puissantes, mais comme il est géré via la ligne de commande, la capacité d'affichage visuel est relativement faible. Rancher dispose d'une interface utilisateur, à travers laquelle diverses fonctions de k8 peuvent être exécutées de manière pratique, et diverses fonctions telles que la collecte de journaux, la gestion de cluster multi-k8 et la surveillance peuvent être ajoutées. Il peut être considéré comme une version améliorée de k8s.

6. Démarrer la configuration

1. Créez d'abord un projet jenkins

  Le premier est la description du projet. Supprimer les anciennes versions consiste à supprimer les anciennes. En général, il est recommandé de configurer (car chaque projet est généré à la fois à plusieurs centaines de Mo et la pression du disque est élevée). Le nombre de jours pour conserver les versions est pour enregistrer les builds en quelques jours, le nombre maximum de builds à conserver est le nombre maximum de builds.

2. Configurer git

  Configurez l'URL de gitlab pour extraire le code. Notez que si elle est rouge, cela est généralement dû à une défaillance du réseau ou à des informations d'identification incorrectes. L'authentification a échoué signifie que les informations d'identification sont incorrectes. Après avoir cliqué sur Ajouter, vous pouvez entrer le mot de passe du compte gitlab à configurer une accréditation.

3. Crochet de configuration

  Permettez-moi de mentionner que le hook est webhook, qui consiste à fournir une interface à gitlab et à le laisser pousser des événements pour dire à jenkins de démarrer le déploiement automatisé.

  Cochez Générer lorsqu'une modification est transmise à GitLab. URL du webhook GitLab, cliquez sur l'option avancée, puis générez la clé, et vous pouvez configurer le hook sur gitlab avec l'URL et la clé.

  Entrez le projet gitlab, cliquez sur le paramètre à gauche pour accéder à la page de configuration du hook, remplissez l'URL et la clé obtenues par jenkins, cochez Trigger et cliquez sur Save, et le hook est configuré. Il convient de noter que les événements push déclenchent le hook à chaque fois que le code est poussé, et que l'événement push de tag déclenche le hook uniquement pour les push de tag. De manière générale, le tag push est sélectionné pour éviter une construction trop fréquente, et le tag peut être utilisé comme une balise miroir en même temps. Distinguer les images qui sont construites à chaque fois.

4. Construction de la configuration et génération d'images

#!/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}

  Cliquez sur ajouter une étape de publication et sélectionnez exécuter le shell pour exécuter le script shell afin de conditionner l'image.

5. Configurer le push k8s

  Jenkins a besoin de plug-ins pour prendre en charge k8. En général, il existe les types suivants:
  Plug- in Kubernetes Cli : Le plug-in peut être directement utilisé dans Jenkins en utilisant la ligne de commande kubernetes.
  Plug-in Kubernetes : pour utiliser kubernetes, vous devez installer le plug-in.
  Kubernetes Continuous Deploy Plugin : le plug-in de déploiement kubernetes peut être utilisé selon les besoins.
  Entrez les paramètres de jenkins en cliquant sur Gérer jenkins, puis cliquez sur Gérer les plugins pour exécuter le plug-in gestion. La plupart des plug-ins peuvent être recherchés et installés directement. Non pris en charge, vous pouvez également télécharger le plug-in via le site Web du plug-in, tel que https://mirrors.tuna.tsinghua.edu.cn/jenkins/ (miroir de l'Université Tsinghua ) ou sur le site officiel https://plugins.jenkins.io/ puis installez le plugin.
  Cliquez ensuite sur ajouter une étape de publication et sélectionnez déployer sur kubernetes (la prise en charge du plug-in est requise).

  S'il n'y a pas de certificat, vous devez obtenir le fichier de configuration kubernetes du cluster kubernetes, cliquez sur le cluster, puis sur le fichier kubeconfig, puis copiez le contenu.


  Cliquez sur ajouter dans les informations d'identification jenkins, sélectionnez kubeconfig pour le genre, cochez entrer directement, collez le contenu kubeconfig précédemment copié dans le contenu, entrez l'ID et la description pour une identification facile, puis enregistrez.

  À ce stade, la configuration de jenkins est terminée. Vous pouvez automatiser le déploiement du conteneur en un seul clic en accrochant ou en cliquant sur Créer maintenant.
  Remarque : Vous devez d'abord créer les espaces de noms et les projets correspondants dans les clusters Harbour et k8s. Vous pouvez vous référer à l'exemple suivant pour le fichier yaml, ou déployer manuellement le service dans Rancher, exporter le yaml et supprimer des paramètres d'heure et d'ID uniques. .

7. Exemple de fichier dockerfile

Exemple de projet général 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"]

Exemple de projet 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. exemple de fichier yaml

Exemple de configuration de charge de travail, 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

Service de cluster (pour l'accès au sein du cluster), 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

Service public, exposition de port (pour l'accès externe au cluster), 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. Registre des problèmes courants

En règle générale, lorsque la génération échoue, vous pouvez cliquer sur une seule génération et sur la sortie de la console pour afficher le journal de génération et la raison de l'échec.

1. jenkins 用 spring-boot-maven-plugin 构建 出错 ： échec du repackage: impossible de trouver la classe principale
   https://blog.csdn.net/qq_35530005/article/details/109333356