penyebaran web docker golang

Dengan perkembangan pesat Internet, penggunaan dan pengurusan aplikasi perusahaan menjadi semakin kompleks. Kemunculan teknologi kontena Docker boleh membantu pembangun sangat memudahkan proses penggunaan aplikasi dan kerja pembinaan persekitaran. Artikel ini akan memperkenalkan cara menggunakan bahasa Go dan teknologi kontena Docker untuk menggunakan dan mengurus aplikasi web.

1. Kerja penyediaan

1.
Anda perlu memasang persekitaran pembangunan bahasa Go dan alatan berkaitan Alamat muat turun ialah: https://golang.org/dl/.

2. Pasang teknologi kontena Docker.
Anda perlu memasang versi terkini Docker CE, alamat muat turun ialah: https://www.docker.com/community-edition.

3. Pasang editor kod.
Artikel ini menggunakan Kod Visual Studio sebagai editor kod Alamat muat turun ialah: https://code.visualstudio.com/download.

4. Buat projek Go Web.
Dalam baris arahan, pergi ke direktori kerja anda dan gunakan arahan berikut untuk mencipta projek Go Web bernama "goweb".

$ go mod init goweb

5. Muat turun pakej pergantungan Go yang diperlukan.
Gunakan arahan berikut untuk memuat turun pakej pergantungan Go yang diperlukan.

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

2 Cipta aplikasi Web

Dalam langkah sebelumnya, rangka kerja Gin telah dipasang sebagai aplikasi Web Dengan mengambil kira sokongan asas program, mari kita cipta aplikasi web yang ringkas.

1 Cipta folder dalam projek dan namakannya "statik" sebagai direktori untuk menyimpan sumber bahagian hadapan dan fail statik.

2. Cipta folder dalam projek bernama "templat" untuk menyimpan fail templat HTML.

3. Cipta fail Go bernama "main.go" dengan kandungan berikut:

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")
}

Kod di atas mencipta tapak web ringkas yang menggunakan rangka kerja Gin untuk memuatkan templat dan fail statik. Laman web tersebut boleh dilihat dengan melayari http://localhost:8080/.

3. Bina imej Docker

Seterusnya, mari kita gunakan Docker untuk membina imej Docker.

1. Buat fail bernama "Dockerfile" dalam direktori akar projek adalah seperti berikut:

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"]

Kod di atas mencipta Dockerfile :1.16 sebagai imej asas, pasang pakej kebergantungan Go yang diperlukan dan salin kod setempat ke imej untuk membina aplikasi. Dalam fasa kedua, versi terkini imej alpine digunakan sebagai imej asas dan fail aplikasi disalin ke dalam bekas untuk dijalankan.

2. Buka baris arahan, masukkan direktori akar projek, dan laksanakan arahan berikut untuk membina imej Docker.

$ docker build -t golang-web .

Arahan di atas akan membaca kandungan fail Dockerfile dan membina imej bernama "golang-web".

3. Jalankan bekas Docker
Jalankan arahan berikut untuk memulakan bekas.

$ docker run -p 8080:8080 golang-web

Arahan di atas akan memulakan bekas bernama "golang-web" dan memetakan port 8080 kontena ke port 8080 hos.

4. Urus berbilang bekas melalui Docker Compose

Jika anda perlu mengurus berbilang bekas pada masa yang sama, anda boleh menggunakan Docker Compose untuk mencipta dan mengurus berbilang bekas.

1. Cipta fail docker-compose.yml
Dalam direktori akar projek, buat fail bernama "docker-compose.yml" dengan kandungan berikut:

version: '3'

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

Di atas Konfigurasi akan mencipta dua perkhidmatan: satu bernama "backend" untuk menjalankan aplikasi web Go; dan satu lagi bernama "frontend" untuk menjalankan pelayan web NGINX sebagai proksi bahagian hadapan.

2. Cipta direktori bahagian hadapan
Dalam direktori akar projek, buat direktori bernama "frontend" dan buat fail HTML bernama "index.html" dengan kandungan berikut.

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

Kod di atas ialah halaman HTML yang ringkas.

3. Mulakan Docker Compose
Masukkan direktori akar projek dalam baris arahan dan jalankan arahan berikut untuk memulakan Docker Compose:

$ docker-compose up -d

Di atas Perintah akan memulakan dua perkhidmatan Ambil perhatian bahawa menggunakan pilihan "-d" membolehkan Docker Compose berjalan di latar belakang.

4. Ringkasan

Melalui pengenalan artikel ini, kami boleh menggunakan bahasa Go dan teknologi kontena Docker untuk membina aplikasi web ringkas dengan cepat dan menggunakan Docker Compose untuk mengurus berbilang bekas. Pendekatan ini boleh memudahkan proses penempatan dan kerja persediaan persekitaran, serta memberikan kemudahan kepada penggunaan pantas dan pengurusan aplikasi perusahaan.

Atas ialah kandungan terperinci penyebaran web docker golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!