Créez des microservices à l'aide du framework Web Iris et de Docker de Golang

Avec le développement continu des applications Internet, l'architecture des microservices devient un modèle d'architecture de plus en plus populaire. L'architecture des microservices conçoit les applications en petits services indépendants les uns des autres et pouvant être mis à jour et déployés régulièrement. Avec le développement du cloud computing, du big data et de l’Internet des objets, l’application de l’architecture de microservices va devenir de plus en plus répandue.

Cet article expliquera comment utiliser le framework Web de Golang, Iris et Docker, pour créer des microservices.

1. Introduction à Iris

Iris est un framework web écrit en Go Il est créé et maintenu par l'équipe Kataras. Le code d'Iris est concis et facile à lire, offre d'excellentes performances, prend en charge les styles de programmation asynchrone et synchrone et prend en charge les architectures MVC et RESTful. Iris est un framework Web émergent qui vise à devenir le « framework Web de nouvelle génération ».

2. Introduction à Docker

Docker est une plateforme de conteneurisation open source qui permet aux développeurs de créer, déployer et exécuter rapidement des applications. Grâce à Docker, vous pouvez inclure votre application et toutes ses dépendances dans un seul conteneur, ce qui rend le déploiement d'applications plus facile et plus fiable. Docker améliore non seulement la portabilité des applications, mais réduit également l'utilisation des ressources d'exécution et les conflits.

3. Utilisez Iris et Docker pour créer des microservices

Dans cet article, nous présenterons comment utiliser Iris et Docker pour créer un microservice simple. Le service fournira deux points de terminaison API : /hello et /time . Le point de terminaison /hello renverra le message « Hello, World ! » et le point de terminaison /time renverra l’heure actuelle.

1. Créer un projet Golang

Tout d'abord, créez un projet Golang. Créez un projet Iris à l'aide de la commande suivante :

$ go get -u github.com/kataras/iris/v12

Assurez-vous que les variables d'environnement sont définies dans l'espace de travail Go.

Créez le fichier main.go et ajoutez le code suivant :

package main

import (
    "github.com/kataras/iris/v12"
    "time"
)

func main() {
    app := iris.New()
    app.Get("/hello", func(ctx iris.Context) {
        ctx.JSON(iris.Map{"message": "Hello, World!"})
    })
    app.Get("/time", func(ctx iris.Context) {
        ctx.JSON(iris.Map{"time": time.Now().Format(time.RFC3339)})
    })
    app.Run(iris.Addr(":8080"))
}

Dans main.go, nous utilisons iris.New() pour créer une nouvelle instance d'application Iris et utilisons la méthode app.Get() pour définir deux routeurs différents . Le point de terminaison /hello du routeur renverra le message « Hello, World ! » et le point de terminaison /time renverra l'heure actuelle. Enfin, exécutez la méthode app.Run() pour démarrer le service et écoutez les connexions sur le port par défaut 8080.

2. Créer un Dockerfile

Ensuite, créez un fichier appelé Dockerfile. Un Dockerfile est un fichier texte qui contient une série d'instructions permettant de créer une image Docker.

Ajoutez le code suivant dans le Dockerfile :

FROM golang:1.16.3-alpine3.13 AS build

RUN apk update && apk upgrade && 
    apk add --no-cache bash git openssh

WORKDIR /go/src/app
COPY . .

RUN go get -d -v ./...
RUN go install -v ./...
RUN go build -o /usr/local/bin/app

FROM alpine:3.13
COPY --from=build /usr/local/bin/app /usr/local/bin/app
ENTRYPOINT ["/usr/local/bin/app"]

Ce Dockerfile construira notre application basée sur l'image Golang 1.16.3-alpine3.13. Nous avons d'abord mis à jour le package d'installation Alpine3.13 et ajouté les packages bash, git et openssh requis. Ensuite, nous définirons le répertoire de travail, copierons notre code d'application dans le répertoire de travail et téléchargerons les dépendances. Enfin, nous exécutons la commande go build pour créer le fichier exécutable binaire et copions le fichier exécutable binaire dans l'image Alpine3.13 pour créer l'image Docker finale.

3. Créez et exécutez le conteneur

Dans le répertoire Dockerfile, utilisez la commande suivante pour créer l'image Docker :

$ docker build -t my-app .

Cette commande créera une image Docker nommée my-app. Nous pouvons utiliser la commande suivante pour exécuter un conteneur Docker :

$ docker run -p 8080:8080 my-app

Cette commande démarrera le conteneur et mappera le port par défaut 8080 au port 8080 de l'hôte à l'aide de l'indicateur -p. Avec l'API publique de l'application exécutée dans le conteneur, nous pouvons tester cette API à l'aide de la commande suivante :

$ curl http://localhost:8080/hello
{"message":"Hello, World!"}
$ curl http://localhost:8080/time
{"time":"2021-05-27T14:14:22+08:00"}

Maintenant, nous avons réussi à créer un microservice simple en utilisant Iris et Docker. Dans les applications réelles, nous pouvons diviser le service en plusieurs microservices pour mieux gérer et faire évoluer l'application.

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!