Déploiement conteneurisé à l'aide de Kubernetes dans Beego

Déploiement conteneurisé à l'aide de Kubernetes dans Beego

Avec la popularité du cloud computing et de la technologie de conteneurisation, de plus en plus d'applications Web commencent à adopter le déploiement conteneurisé. Dans le déploiement conteneurisé, Kubernetes est devenu l'un des standards de facto. Cet article explique comment utiliser Kubernetes pour le déploiement conteneurisé dans Beego.

1. Qu'est-ce que Beego ?

Beego est un framework MVC simple et rapide basé sur Go (Golang). Il s'agit d'un framework open source qui peut être utilisé pour développer rapidement des applications Web hautes performances, évolutives, maintenables et testables.

2. Qu'est-ce que Kubernetes ?

Kubernetes est un système d'orchestration de conteneurs open source pour gérer les applications conteneurisées. Il offre la possibilité d'automatiser le déploiement, la mise à l'échelle et la gestion des applications conteneurisées. Kubernetes peut fonctionner dans des environnements de cloud privé et public et peut être déployé sur plusieurs fournisseurs de cloud.

3. Pourquoi utiliser Kubernetes pour le déploiement de conteneurs dans Beego ?

L'utilisation de Kubernetes pour le déploiement conteneurisé dans Beego présente les avantages suivants :

1. Portabilité : Grâce à la technologie de déploiement conteneurisé, les applications peuvent être placées dans des conteneurs et déployées à l'aide de Kubernetes n'importe où.

2. Mise à l'échelle automatique : utilisez Kubernetes pour étendre et réduire automatiquement les conteneurs d'applications horizontalement afin de répondre aux changements de trafic.

3. Haute disponibilité : la haute disponibilité peut être obtenue à l'aide de Kubernetes. Si un nœud tombe en panne, Kubernetes redémarrera automatiquement le conteneur sur les autres nœuds.

4. Facile à gérer : l'utilisation de Kubernetes simplifie la gestion des applications et de l'infrastructure.

4. Comment utiliser Kubernetes pour le déploiement de conteneurs dans Beego ?

Voici les étapes du déploiement conteneurisé à l'aide de Kubernetes dans Beego :

1 Écrivez un Dockerfile : Un Dockerfile est un fichier de script permettant de créer un conteneur Docker. Dans le répertoire racine de l'application Beego, créez un fichier nommé Dockerfile et ajoutez le contenu suivant :

FROM golang:1.13 as builder
WORKDIR /app
COPY . .
RUN go mod download
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -a -installsuffix cgo -o app .

FROM alpine
RUN apk update && apk add --no-cache ca-certificates
WORKDIR /root/
COPY --from=builder /app/app .
CMD ["./app"]

Dans le fichier Dockerfile ci-dessus, la ligne 1 précise que l'image de base utilisée est l'image officielle golang:1.13, et la ligne 2 précise le job Le répertoire est /app. La ligne 3 copie l'application Beego dans le conteneur. Line 4 télécharge les modules requis par l'application. La ligne 5 compile. Line 7 copie l'application dans une autre image de base, alpine, qui est petite et ne contient que les fichiers nécessaires. La dernière ligne spécifie la commande à exécuter au démarrage du conteneur.

2. Créez l'image Docker : accédez au répertoire où se trouve le fichier Dockerfile dans le terminal et exécutez la commande suivante pour créer l'image Docker :

docker build -t [image name] .

Où [nom de l'image] est le nom de l'image Docker à créer. créé. Par exemple, vous pouvez utiliser la commande suivante pour créer une image Docker nommée my-app :

docker build -t my-app .

3. Déployer à l'aide de Kubernetes : Dans Kubernetes, vous pouvez utiliser les trois méthodes suivantes pour déployer :

(1) Déployer à l'aide de Deployment : Utilisez le fichier de ressources de déploiement (deployment.yaml) pour définir le déploiement de l'application. Ce fichier de ressources définit l'image du conteneur à utiliser, le nombre de copies et d'autres informations. Voici un exemple de fichier déploiement.yaml :

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

Dans ce fichier, la ligne 1 spécifie la version de l'API, la ligne 2 spécifie la ressource (déploiement) à créer, la ligne 4 spécifie le nom de la ressource et la ligne 7 spécifie le sélecteur. Pour indiquer le Pod à contrôler, la ligne 10 précise le nombre de copies et la ligne 13 précise les informations sur l'image du conteneur.

(2) Utiliser le déploiement d'un Pod : Utilisez le fichier de ressources Pod (pod.yaml) pour définir le déploiement d'un Pod. Spécifiez des informations telles que l'image du conteneur et le port d'application à utiliser dans le fichier de ressources. Voici un exemple de fichier pod.yaml :

apiVersion: v1
kind: Pod
metadata:
  name: my-app-pod
spec:
  containers:
    - name: my-app-container
      image: my-app
      imagePullPolicy: Always
      ports:
        - containerPort: 8080

Dans ce fichier, la ligne 1 précise la version de l'API, la ligne 2 précise la ressource (Pod) à créer, la ligne 5 précise le nom de la ressource et la ligne 7 précise la ressource à créer. use Le nom de l'image du conteneur, la ligne 10 spécifie le port de l'application.

(3) Utiliser le déploiement du service : utilisez le fichier de ressources du service (service.yaml) pour définir l'objet Service. Ce fichier spécifie des informations telles que le port à mapper et le type de service. Voici un exemple de fichier service.yaml :

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

Dans ce fichier, la ligne 1 spécifie la version de l'API, la ligne 2 spécifie la ressource (Service) à créer, la ligne 5 spécifie le nom de la ressource et la ligne 7 spécifie le sélection du service. La 9ème ligne spécifie le type de service et la 10ème ligne spécifie la relation correspondante entre le port de mappage de service et le port du conteneur.

Voici les étapes ci-dessus pour un déploiement conteneurisé à l'aide de Kubernetes dans Beego. De cette façon, les applications Beego peuvent être déployées rapidement et facilement.

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!