So stellen Sie Front-End-Gitlab-Projekte automatisch für k8s bereit

In diesem Artikel wird hauptsächlich die automatische Bereitstellung von Front-End-Projekten in einer Kubernetes-basierten Containerumgebung vorgestellt. Hier verwenden wir GitLab CI/CD, um diesen Prozess abzuschließen. GitLab dient als Plattform für Codeverwaltung, Versionskontrolle und Zusammenarbeit, und Kubernetes dient als Tool für die Container-Orchestrierung und -Bereitstellung, was den Front-End-Entwicklungsprozess effizienter und effizienter gestalten kann komfortabel.

1. GitLab-Konfiguration

Erstellen Sie zunächst ein Projekt auf GitLab und verknüpfen Sie es mit dem Git-Repository. Aktivieren Sie dann die CI/CD-Funktion in den Projekteinstellungen und wählen Sie den Runner aus, den Sie verwenden möchten. Hier installieren wir GitLab Runner und registrieren es in der Runner-Liste von GitLab.

2. GitLab Runner Installation und Konfiguration

Der Prozess der Installation von GitLab Runner ist relativ einfach. Sie müssen lediglich den Installationsanleitungen verschiedener Systeme und Plattformen folgen.

Nachdem die Installation abgeschlossen ist, müssen wir GitLab Runner konfigurieren. Vorausgesetzt, Sie verfügen bereits über einen Kubernetes-Cluster, müssen wir GitLab Runner für die Ausführung auf dem Cluster konfigurieren. Der spezifische Konfigurationsprozess ist wie folgt:

① Zuerst müssen wir ein Kubernetes-Dienstkonto für den Runner konfigurieren. Das Dienstkonto muss für den Zugriff auf die Kubernetes-API im Cluster autorisiert sein.

② Anschließend müssen wir diesen Runner so konfigurieren, dass er das Dienstkonto für den Zugriff auf die API verwendet. Dazu müssen wir die folgenden Felder in der Konfigurationsdatei des Runners (config.toml) festlegen:

[[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"

Darunter ist kube-config der Name der Konfigurationszuordnung, die sich auf den Runner bezieht. runner-secret ist der Name des Geheimnisses, das sich auf Runner bezieht. 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

③ Abschließend müssen wir GitLab Runner aktualisieren und neu starten, damit es Container verwenden kann, die in Kubernetes ausgeführt werden. Führen Sie den folgenden Befehl aus, um GitLab Runner automatisch neu zu starten:

kubectl apply -f deployment.yml

Automatisierte Bereitstellung

Nachdem wir einen konfigurierten Runner erhalten haben, können wir mit der Implementierung der automatisierten Bereitstellung beginnen. Hier verwenden wir eine Datei namens .gitlab-ci.yml, um unseren CI/CD-Prozess zu definieren.

🎜Zuerst müssen wir eine Docker-Datei definieren, die beim Ausführen von Containern in Kubernetes verwendet werden soll. Diese Docker-Datei wird beim Erstellen des Docker-Images verwendet, wie unten gezeigt: 🎜rrreee🎜Das Image basiert auf nginx:1.15.8-alpine. Kopieren Sie unsere Front-End-Dateien in das Standardverzeichnis von Nginx. Und ersetzen Sie die Standard-Nginx-Konfigurationsdatei, damit unsere Anwendung normal ausgeführt werden kann. 🎜🎜Dann definieren Sie unseren CI/CD-Prozess in der Datei .gitlab-ci.yml. Konkret deklarieren wir den Build-Prozess des Projekts in dieser Datei, übertragen dann das erstellte Docker-Image in die Container-Image-Bibliothek und führen dieses Image schließlich in Kubernetes aus. Der Prozess ist wie folgt: 🎜rrreee🎜In dieser Datei erklären wir zunächst, dass unser Prozess zwei Phasen hat: build und release und in build Der Prozess des Erstellens und Übertragens in die Container-Image-Bibliothek wird in der Phase abgeschlossen, und der Kubernetes-Bereitstellungsprozess wird in der Phase release abgeschlossen. Beachten Sie, dass wir hier den CI/CD-Prozess nur für Git-Commits aktivieren, deren Tags Versionsnummern sind. 🎜
🎜Anwendungsbereitstellung🎜🎜🎜Stellen Sie schließlich unsere Anwendung in unserem Kubernetes bereit. Wir werden eine Datei namens deployment.yml verwenden, um die Bereitstellung abzuschließen. Diese Datei deklariert ein Deployment-Objekt zum Ausführen von Front-End-Anwendungen in Kubernetes. 🎜rrreee🎜Diese Datei gibt die Anzahl der Replikate des Deployment-Objekts an (hier ist 1) und deklariert den Namen und die Portnummer des Container-Images. Nachdem wir diese Bereitstellungsdatei fertiggestellt haben, können wir das Kubernetes-Befehlszeilentool (kubectl) verwenden, um das Bereitstellungsobjekt zu erstellen: 🎜rrreee🎜An diesem Punkt sollte unsere Front-End-Anwendung erfolgreich auf Kubernetes ausgeführt werden können. 🎜🎜Fazit🎜🎜In diesem Artikel wird erläutert, wie Sie Front-End-Projekte automatisch in einer Kubernetes-basierten Containerumgebung bereitstellen. Der Schwerpunkt liegt auf der Verwendung von GitLab CI/CD, Kubernetes und Docker und demonstriert den Bereitstellungsprozess anhand einer vollständigen DEMO. Ich hoffe, dass dieser Artikel für Front-End-Entwicklungsingenieure hilfreich ist. 🎜

Das obige ist der detaillierte Inhalt vonSo stellen Sie Front-End-Gitlab-Projekte automatisch für k8s bereit. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!