Créez des applications à l'aide du framework Web Echo de Golang et de Kubernetes.

Avec le développement de la technologie de cloud computing et de conteneurisation, de plus en plus d'entreprises commencent à utiliser Kubernetes pour gérer et déployer des applications. En tant que langage de développement hautes performances, Golang est de plus en plus privilégié par les développeurs. Cet article explique comment utiliser le framework Web Echo de Golang et Kubernetes pour créer des applications.

Installer le framework Go et Echo

Tout d'abord, nous devons installer l'environnement de développement Golang et le framework Echo localement. L'installation du framework Golang et Echo peut être réalisée selon les documents officiels, et ne sera pas décrite en détail ici.

Rédaction d'une application

Créez un nouveau projet Golang dans votre environnement de développement local. Nous allons créer une application Web simple grâce à laquelle les utilisateurs pourront interroger l'heure actuelle. Créez un nouveau dossier et créez un fichier appelé main.go. Copiez le code suivant dans le fichier :

package main

import (
    "net/http"
    "time"

    "github.com/labstack/echo"
    "github.com/labstack/echo/middleware"
)

func main() {
    e := echo.New()

    // Middleware
    e.Use(middleware.Logger())
    e.Use(middleware.Recover())

    // Routes
    e.GET("/", func(c echo.Context) error {
        return c.String(http.StatusOK, time.Now().String())
    })

    // Start server
    e.Logger.Fatal(e.Start(":8080"))
}

Dans le code ci-dessus, nous avons utilisé le framework Echo pour créer un serveur HTTP lorsque l'utilisateur accède au chemin racine. l'heure actuelle.

Applications Dockerisées

Pour simplifier le processus de déploiement, nous conteneurisons l'application et la téléchargeons sur Docker Hub. Créez un fichier nommé Dockerfile et copiez le code suivant dans le fichier :

FROM golang:1.13-alpine

RUN apk --no-cache add gcc g++ make

WORKDIR /app

COPY . .

RUN go build -o main .

EXPOSE 8080

CMD ["./main"]

Dans le code ci-dessus, nous avons utilisé l'image 1.13-alpine officiellement fournie par Golang comme image de base, installé les dépendances de compilation et copié le code source dans le conteneur . Exécutez ensuite la commande go build pour compiler le fichier exécutable et enfin démarrer le serveur web.

Exécutez la commande suivante dans le répertoire racine du projet pour créer l'image Docker :

docker build -t yourdockerhubusername/echo-app .

Déployer sur Kubernetes

Avant le déploiement, nous devons installer l'outil Kubectl localement et il doit y avoir un cluster Kubernetes disponible. Pour les étapes détaillées d'installation et de configuration de l'outil Kubectl, veuillez vous référer à la documentation officielle de Kubernetes.

Créez un fichier nommé echo-deployment.yaml et copiez le code suivant dans le fichier :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: echo-app
  labels:
    app: echo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: echo
  template:
    metadata:
      labels:
        app: echo
    spec:
      containers:
      - name: echo-app
        image: yourdockerhubusername/echo-app
        ports:
        - containerPort: 8080

Dans le code ci-dessus, nous créons un déploiement nommé echo-app tout en utilisant l'image du conteneur yourdockerhubusername /echo-app pour exécuter l'application. . Le nombre de copies de cette instance de déploiement est de 2, et chaque copie démarre un serveur Web et écoute le port 8080.

Ensuite, nous devons créer un service pour exposer l'instance de déploiement echo-app. Créez un fichier appelé echo-service.yaml et copiez le code suivant dans le fichier :

apiVersion: v1
kind: Service
metadata:
  name: echo-service
spec:
  ports:
  - name: http
    port: 80
    targetPort: 8080
  selector:
    app: echo

Dans le code ci-dessus, nous avons créé un service appelé echo-service qui écoute sur le port 80 et transmet les requêtes au port 8080 de l'écho. -app Instance de déploiement.

Exécutez la commande suivante dans le répertoire racine du projet pour déployer l'application :

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

Une fois la commande ci-dessus terminée, vous pouvez afficher l'adresse IP du service via la commande suivante :

kubectl get svc echo-service

Ensuite, visitez http:// < dans le navigateur ;Service_IP>, l'application doit s'exécuter normalement et renvoyer l'heure actuelle.

À ce stade, nous avons réussi à créer une application Web simple en utilisant le framework Echo de Golang et Kubernetes. Cette méthode est simple et efficace et peut grandement améliorer l’efficacité du développement et du déploiement.

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!