Comment déployer automatiquement des projets gitlab front-end sur k8

Cet article explique principalement comment déployer automatiquement des projets frontaux dans un environnement de conteneurs basé sur Kubernetes. Ici, nous utilisons GitLab CI/CD pour compléter ce processus. GitLab sert de plate-forme pour la gestion du code, le contrôle des versions et la collaboration, et Kubernetes sert d'outil pour l'orchestration et le déploiement de conteneurs, ce qui peut rendre le processus de développement front-end plus efficace et plus efficace. pratique.

1. Configuration GitLab

Créez d'abord un projet sur GitLab et associez-le au référentiel Git. Ensuite, activez la fonction CI/CD dans les paramètres du projet et sélectionnez le Runner que vous souhaitez utiliser. Ici, nous allons installer GitLab Runner et l'enregistrer dans la liste Runner de GitLab.

2. Installation et configuration de GitLab Runner

Le processus d'installation de GitLab Runner est relativement simple. Il vous suffit de suivre les guides d'installation des différents systèmes et plates-formes.

Une fois l'installation terminée, nous devons configurer GitLab Runner. En supposant que vous disposez déjà d'un cluster Kubernetes, nous devons configurer GitLab Runner pour qu'il s'exécute sur le cluster. Le processus de configuration spécifique est le suivant :

① Tout d'abord, nous devons configurer un compte de service Kubernetes pour le Runner. Le compte de service doit être autorisé à accéder à l'API Kubernetes dans le cluster.

② Par la suite, nous devons configurer ce Runner pour qu'il utilise le compte de service pour accéder à l'API. Pour ce faire, nous devons définir les champs suivants dans le fichier de configuration du Runner (config.toml) :

[[runners.kubernetes.volumes.host_path]]
      name = "docker"
      mount_path = "/var/run/docker.sock"
      host_path = "/var/run/docker.sock"
    [[runners.kubernetes.volumes.config_map]]
      name = "kube-config"
      mount_path = "/etc/kubernetes"
    [[runners.kubernetes.volumes.empty_dir]]
      name = "tls"
      mount_path = "/etc/gitlab-runner/certs"
    [[runners.kubernetes.volumes.secret]]
      name = "runner-secret"
      mount_path = "/etc/gitlab-runner"

Parmi eux, kube-config est le nom de la map de configuration liée au Runner, runner-secret est le nom du secret lié à Runner. kube-config为与Runner相关的config map的名称，runner-secret为与Runner相关的secret的名称。

③ 最后，我们需要更新并重启GitLab Runner，使其能够使用在Kubernetes中运行的容器。运行以下命令可以自动重启GitLab Runner：

sudo gitlab-runner restart

3. 实现自动化部署

获得了一个配置好的Runner之后，我们就可以开始实现自动化部署了。这里我们使用一个名为.gitlab-ci.yml的文件来定义我们的CI/CD流程。

首先，我们需要定义一个Dockerfile，以便在Kubernetes中运行容器时使用。该Dockerfile将在构建Docker镜像时使用，如下所示：

FROM nginx:1.15.8-alpine

COPY dist /usr/share/nginx/html

COPY nginx/default.conf /etc/nginx/conf.d/

该镜像将以nginx:1.15.8-alpine为基础镜像，复制我们的前端文件到Nginx的默认目录，并替换默认的Nginx配置文件以便于我们的应用能够正常运行。

随后，在.gitlab-ci.yml文件中定义我们的CI/CD流程。具体地，我们将在该文件中声明该项目的构建过程，然后将该构建后的Docker镜像推送到容器镜像库，并最终在Kubernetes中运行这个镜像。流程如下：

stages:
  - build
  - release

build:
  stage: build
  script:
    - docker build -t registry.cn-hangzhou.aliyuncs.com/$CI_PROJECT_NAMESPACE/$CI_PROJECT_NAME:$CI_COMMIT_TAG .
    - docker login -u $DOCKER_USERNAME -p $DOCKER_PASSWORD registry.cn-hangzhou.aliyuncs.com
    - docker push registry.cn-hangzhou.aliyuncs.com/$CI_PROJECT_NAMESPACE/$CI_PROJECT_NAME:$CI_COMMIT_TAG
  only:
    - /^v\d+\.\d+(\.\d+)?(-\S*)?$/

release:
  stage: release
  script:
    - kubectl apply -f k8s/
  only:
    - /^v\d+\.\d+(\.\d+)?(-\S*)?$/

在这个文件中，我们首先声明了我们的流程拥有build和release两个阶段，并在build阶段中完成构建、推送到容器镜像库的过程，在release阶段中完成Kubernetes部署的过程。注意，这里我们只为tag为版本号的Git提交启用CI/CD流程。

4. 应用部署

最后，在我们的Kubernetes中部署上我们的应用。我们将使用一个名为deployment.yml的文件来完成部署。该文件声明了一个Deployment对象，用于在Kubernetes中运行前端应用。

apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend-deployment
spec:
  replicas: 1 # 运行一个副本
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
        - name: frontend
          image: registry.cn-hangzhou.aliyuncs.com/wbbry/frontend:latest # 镜像名称
          imagePullPolicy: Always
          ports:
            - containerPort: 80 # 前端端口

该文件指定了该Deployment对象的replicas

③ Enfin, nous devons mettre à jour et redémarrer GitLab Runner afin qu'il puisse utiliser des conteneurs exécutés dans Kubernetes. Exécutez la commande suivante pour redémarrer automatiquement GitLab Runner :

kubectl apply -f deployment.yml

Déploiement automatisé

Après avoir obtenu un Runner configuré, nous pouvons commencer à implémenter le déploiement automatisé. Ici, nous utilisons un fichier nommé .gitlab-ci.yml pour définir notre processus CI/CD.

🎜Tout d'abord, nous devons définir un Dockerfile à utiliser lors de l'exécution de conteneurs dans Kubernetes. Ce fichier Docker sera utilisé lors de la construction de l'image Docker, comme indiqué ci-dessous : 🎜rrreee🎜L'image sera basée sur nginx:1.15.8-alpine. Copiez nos fichiers frontaux dans le répertoire par défaut de. Nginx. Et remplacez le fichier de configuration Nginx par défaut pour que notre application puisse fonctionner normalement. 🎜🎜Ensuite, définissez notre processus CI/CD dans le fichier .gitlab-ci.yml. Plus précisément, nous déclarerons le processus de construction du projet dans ce fichier, puis pousserons l'image Docker construite vers la bibliothèque d'images du conteneur et enfin exécuterons cette image dans Kubernetes. Le processus est le suivant : 🎜rrreee🎜Dans ce fichier, nous déclarons d'abord que notre processus comporte deux étapes : build et release, et dans build Le processus de création et de transfert vers la bibliothèque d'images du conteneur est terminé au cours de l'étape, et le processus de déploiement de Kubernetes est terminé au cours de l'étape release. Notez qu'ici, nous activons uniquement le processus CI/CD pour les commits Git dont les balises sont des numéros de version. 🎜
🎜Déploiement d'application🎜🎜🎜Enfin, déployez notre application dans notre Kubernetes. Nous utiliserons un fichier appelé deployment.yml pour terminer le déploiement. Ce fichier déclare un objet Deployment pour exécuter des applications frontales dans Kubernetes. 🎜rrreee🎜Ce fichier spécifie le nombre de réplicas de l'objet Deployment (ici 1), et déclare le nom et le numéro de port de l'image du conteneur. Après avoir terminé ce fichier de déploiement, nous pouvons utiliser l'outil de ligne de commande Kubernetes (kubectl) pour créer l'objet Deployment : 🎜rrreee🎜À ce stade, notre application frontale devrait pouvoir s'exécuter avec succès sur Kubernetes. 🎜🎜Conclusion🎜🎜Cet article explique comment déployer automatiquement des projets frontaux dans un environnement de conteneurs basé sur Kubernetes. Il se concentre sur l'utilisation de GitLab CI/CD, Kubernetes et Docker, et démontre le processus de déploiement à travers une DÉMO complète. J'espère que cet article sera utile aux ingénieurs de développement front-end. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!