Produktionsbereitstellung und -verwaltung mit Docker und Kubernetes in Beego

Mit der rasanten Entwicklung des Internets beginnen immer mehr Unternehmen, ihre Anwendungen auf Cloud-Plattformen zu migrieren. Docker und Kubernetes sind zu zwei sehr beliebten und leistungsstarken Tools für die Anwendungsbereitstellung und -verwaltung auf Cloud-Plattformen geworden.

Beego ist ein mit Golang entwickeltes Web-Framework, das umfangreiche Funktionen wie HTTP-Routing, MVC-Layering, Protokollierung, Konfigurationsverwaltung, Sitzungsverwaltung usw. bietet. In diesem Artikel stellen wir vor, wie Sie mit Docker und Kubernetes Beego-Anwendungen bereitstellen und verwalten, um eine schnelle Bereitstellung und Verwaltung von Anwendungen zu ermöglichen.

Einführung in Docker

Docker ist eine Container-basierte Virtualisierungstechnologie, die es Entwicklern ermöglicht, Anwendungen und alle abhängigen Bibliotheken, Konfigurationsdateien usw. in einen Container zu packen, wodurch sichergestellt wird, dass die Anwendung in jeder Umgebung ausgeführt werden kann Alle abhängigen Bibliotheken und Konfigurationen sind genau gleich.

Wenn wir Docker zum Bereitstellen einer Beego-Anwendung verwenden, können wir die Anwendung, alle abhängigen Bibliotheken und Konfigurationsdateien in einen Container packen und den Container einem bestimmten Port auf dem Host-Computer zuordnen. Auf diese Weise können wir über die IP-Adresse und den Port des Host-Computers auf unsere Beego-Anwendung zugreifen.

Docker stellt Beego-Anwendungen bereit

Wenn wir Docker zum Bereitstellen von Beego-Anwendungen verwenden, müssen wir die folgenden Schritte ausführen:

1. Docker installieren

Bitte befolgen Sie die offizielle Dokumentation, um Docker zu installieren: https://docs.docker.com /install/

2. Dockerfile erstellen

Dockerfile ist eine reine Textdatei, die alle Anweisungen zum Erstellen eines Docker-Images enthält. In der Docker-Datei müssen wir das zu verwendende Docker-Image angeben, die Anwendung und alle abhängigen Bibliotheken und Konfigurationsdateien in den Container kopieren, die Beego-Anwendung starten usw.

Ein einfaches Beispiel für eine Docker-Datei lautet wie folgt:

# 使用golang 1.13版本的Docker镜像
FROM golang:1.13

# 将当前目录下的所有文件复制到容器中/app目录下
ADD . /app

# 设置工作目录为/app
WORKDIR /app

# 编译Beego应用程序
RUN go build main.go

# 暴露8080端口
EXPOSE 8080

# 启动Beego应用程序
CMD ["./main"]

3. Erstellen Sie das Docker-Image

Führen Sie in dem Verzeichnis, in dem sich die Docker-Datei befindet, den folgenden Befehl aus, um das Docker-Image zu erstellen:

docker build -t myapp:latest .

Dieser Befehl packt alle Dateien in dem Verzeichnis, in dem sich die Docker-Datei befindet, in ein Docker-Image mit der Bezeichnung myapp:latest.

4. Führen Sie den Docker-Container aus.

Nachdem wir das Docker-Image erstellt haben, können wir den folgenden Befehl verwenden, um den Docker-Container auszuführen:

docker run -p 8080:8080 myapp:latest

Dieser Befehl führt das Docker-Image mit der Bezeichnung myapp:latest aus und ordnet den 8080-Port des Containers zu an Port 8080 des Host-Computers.

5. Zugriff auf die Beego-Anwendung

Jetzt können wir auf unsere Beego-Anwendung zugreifen, indem wir über den Browser auf http://localhost:8080 zugreifen.

Einführung in Kubernetes

Kubernetes ist ein Open-Source-Container-Orchestrierungstool, das Containeranwendungen automatisch bereitstellen, skalieren und verwalten kann. Durch die Verwendung von Kubernetes können Anwendungen mit Funktionen wie hoher Verfügbarkeit, Skalierbarkeit und Fehlertoleranz ausgestattet werden.

Bei der Bereitstellung einer Beego-Anwendung mit Kubernetes müssen wir zunächst die Anwendung und alle abhängigen Bibliotheken und Konfigurationsdateien in ein Docker-Image packen und dieses Docker-Image dann im Kubernetes-Cluster bereitstellen. Kubernetes führt dieses Docker-Image automatisch auf einem Knoten im Kubernetes-Cluster aus und macht den Service-Port nach außen zugänglich.

Kubernetes stellt Beego-Anwendungen bereit

Bei der Verwendung von Kubernetes zur Bereitstellung von Beego-Anwendungen müssen wir die folgenden Schritte ausführen:

1. Installieren und konfigurieren Sie den Kubernetes-Cluster

Bitte lesen Sie die offizielle Dokumentation, um den Kubernetes-Cluster zu installieren und zu konfigurieren: https://kubernetes.io/docs/setup/

2. Bereitstellung erstellen

In Kubernetes verwenden wir Bereitstellung, um eine replizierbare Sammlung von Containern zu definieren, die dieselbe Konfiguration und dieselben Speichervolumes verwenden. Kubernetes weist diese Pods (Container) automatisch einem Knoten im Cluster zu und überprüft ihren Status, um eine hohe Verfügbarkeit und Fehlertoleranz der Anwendung sicherzustellen.

Ein einfaches Bereitstellungsbeispiel lautet wie folgt:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:latest
        ports:
        - containerPort: 8080

Diese Bereitstellung definiert eine replizierbare Containersammlung mit dem Namen myapp-deployment, die 3 Pods enthält, und verwendet die Bezeichnung app=myapp, um den Pod auszuwählen. Die in jedem Pod ausgeführten Container verwenden das myapp:latest-Image und machen Container-Port 8080 verfügbar.

3. Dienst erstellen

In Kubernetes verwenden wir einen Dienst, um die Pods im Deployment der Außenwelt zugänglich zu machen. Der Dienst weist Pods eine virtuelle IP und einen Port zu und leitet alle Anfragen an diese Pods weiter.

Ein einfaches Service-Beispiel lautet wie folgt:

apiVersion: v1
kind: Service
metadata:
  name: myapp-service
spec:
  selector:
    app: myapp
  ports:
  - name: http
    port: 8080
    targetPort: 8080
  type: LoadBalancer

Dieser Service definiert einen Lastausgleichsdienst namens myapp-service, der die Anfrage mit der Bezeichnung app=myapp an den Pod weiterleitet und den Container-Port 8080 dem Service-Port zuordnet.

4. Stellen Sie die Beego-Anwendung bereit

Nachdem Sie die Bereitstellung und den Dienst erstellt haben, können wir den folgenden Befehl verwenden, um die Beego-Anwendung bereitzustellen:

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

Dieser Befehl stellt eine replizierbare Containersammlung und einen Lastausgleichsdienst bereit und fügt sie hinzu in einem Kubernetes-Cluster.

5. Greifen Sie auf die Beego-Anwendung zu

Jetzt können wir den Befehl kubectl get svc verwenden, um die virtuelle IP und den Port des Dienstes abzurufen, und dann über den Browser auf unsere Beego-Anwendung zugreifen.

Zusammenfassung

In diesem Artikel haben wir vorgestellt, wie Sie Docker und Kubernetes zum Bereitstellen und Verwalten von Beego-Anwendungen verwenden. Mit diesen beiden Tools können wir Anwendungen schnell auf der Cloud-Plattform bereitstellen und Anwendungskonsistenz, hohe Verfügbarkeit, Skalierbarkeit und Fehlertoleranz sicherstellen. Man geht davon aus, dass diese Technologien bei der Bereitstellung und Verwaltung immer komplexerer Internetanwendungen helfen werden.

Das obige ist der detaillierte Inhalt vonProduktionsbereitstellung und -verwaltung mit Docker und Kubernetes in Beego. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!