Déploiement Web Golang Docker

Avec le développement rapide d'Internet, le déploiement et la gestion des applications d'entreprise sont devenus de plus en plus complexes. L'émergence de la technologie des conteneurs Docker peut aider les développeurs à simplifier considérablement le processus de déploiement d'applications et le travail de construction d'environnement. Cet article explique comment utiliser le langage Go et la technologie de conteneur Docker pour déployer et gérer des applications Web.

1. Préparation

1. Installez l'environnement de développement du langage Go.
Vous devez installer l'environnement de développement du langage Go et les outils associés. L'adresse de téléchargement est : https://golang.org/dl/.

2. Installez la technologie de conteneur Docker.
Vous devez installer la dernière version de Docker CE, l'adresse de téléchargement est : https://www.docker.com/community-edition.

3. Installez l'éditeur de code.
Cet article utilise Visual Studio Code comme éditeur de code. L'adresse de téléchargement est : https://code.visualstudio.com/download.

4. Créez un projet Go Web.
Dans la ligne de commande, accédez à votre répertoire de travail et utilisez la commande suivante pour créer un projet Go Web nommé "goweb".

$ go mod init goweb

5. Téléchargez les packages de dépendances Go requis.
Utilisez la commande suivante pour télécharger les packages de dépendances Go requis.

$ go get -u github.com/gin-gonic/gin

2. Créer une application Web

Dans l'étape précédente, le framework Gin a été installé comme support de base pour les applications Web. Ensuite, créons. une simple application web.

1. Créez un dossier dans le projet et nommez-le « statique » en tant que répertoire pour stocker les ressources frontales et les fichiers statiques.

2. Créez un dossier dans le projet nommé « modèles » pour stocker les fichiers de modèles HTML.

3. Créez un fichier Go nommé "main.go" avec le contenu suivant :

package main

import "github.com/gin-gonic/gin"

func main() {
    router := gin.Default()
    router.LoadHTMLGlob("templates/*")
    router.Static("/static", "./static")
    router.GET("/", func(c *gin.Context) {
        c.HTML(200, "index.tmpl", gin.H{
            "title": "Golang Docker Web Deployment",
        })
    })
    router.Run(":8080")
}

Le code ci-dessus crée un site Web simple qui utilise le framework Gin pour charger des modèles et des fichiers statiques. Le site Web peut être consulté en visitant http://localhost:8080/.

3. Créer une image Docker

Ensuite, utilisons Docker pour créer une image Docker.

1. Créez un fichier nommé "Dockerfile" dans le répertoire racine du projet. Le contenu du fichier est le suivant :

FROM golang:1.16 AS build

WORKDIR /app

COPY go.mod go.sum ./
RUN go mod download

COPY . .

RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o app .

FROM alpine:latest

RUN apk --no-cache add ca-certificates

WORKDIR /root/

COPY --from=build /app/app .

EXPOSE 8080

CMD ["./app"]

Le code ci-dessus crée un Dockerfile. Dans un premier temps, utilisez golang:1.16 comme image de base pour tout installer. Packages de dépendances Go requis et copiez le code local dans l’image pour créer l’application. Dans la deuxième phase, la dernière version de l'image alpine est utilisée comme image de base et les fichiers d'application sont copiés dans le conteneur pour être exécutés.

2. Ouvrez la ligne de commande, entrez le répertoire racine du projet et exécutez la commande suivante pour créer l'image Docker.

$ docker build -t golang-web .

La commande ci-dessus lira le contenu du fichier Dockerfile et construira une image nommée "golang-web".

3. Exécutez le conteneur Docker
Exécutez la commande suivante pour démarrer le conteneur.

$ docker run -p 8080:8080 golang-web

La commande ci-dessus démarrera un conteneur nommé "golang-web" et mappera le port 8080 du conteneur au port 8080 de l'hôte.

4. Gérez plusieurs conteneurs via Docker Compose

Si vous devez gérer plusieurs conteneurs en même temps, vous pouvez utiliser Docker Compose pour créer et gérer plusieurs conteneurs.

1. Créez le fichier docker-compose.yml
Dans le répertoire racine du projet, créez un fichier nommé "docker-compose.yml" avec le contenu suivant :

version: '3'

services:
  backend:
    build: .
    ports:
      - "8080:8080"
    command: ["./app"]
  frontend:
    image: nginx:alpine
    volumes:
      - ./frontend:/usr/share/nginx/html
    ports:
      - "80:80"

La configuration ci-dessus créera deux services : un nommé Le service « backend » est utilisé pour exécuter les applications Web Go ; l'autre service nommé « frontend » est utilisé pour exécuter le serveur Web NGINX en tant que proxy frontal.

2. Créez le répertoire frontend
Dans le répertoire racine du projet, créez un répertoire nommé "frontend" et créez un fichier HTML nommé "index.html" avec le contenu suivant.

<!DOCTYPE html>
<html>
<head>
    <title>Go Docker Web Deployment</title>
</head>
<body>
    <h1>Hello World!</h1>
</body>
</html>

Le code ci-dessus est une simple page HTML.

3. Démarrez Docker Compose
Entrez le répertoire racine du projet dans la ligne de commande et exécutez la commande suivante pour démarrer Docker Compose :

$ docker-compose up -d

La commande ci-dessus démarrera deux services. l'option "-d" Vous pouvez exécuter Docker Compose en arrière-plan.

4. Résumé

Grâce à l'introduction de cet article, nous pouvons rapidement créer une application Web simple en utilisant le langage Go et la technologie de conteneur Docker, et utiliser Docker Compose pour gérer plusieurs conteneurs. Cette méthode peut grandement simplifier le processus de déploiement et le travail de configuration de l'environnement, et facilite le déploiement et la gestion rapides des applications d'entreprise.

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!