dokcer cluster golang build

Dalam bidang pengkomputeran awan, teknologi kontena diutamakan kerana ringan, operasi pantas, mudah alih dan kecekapannya. Sebagai wakil teknologi kontena, Docker telah menjadi alat popular dalam pengkomputeran awan, DevOps dan bidang lain dengan menyediakan cara yang ringan untuk membungkus dan menggunakan aplikasi. Untuk aplikasi peringkat perusahaan, kelompok Docker diperlukan untuk mencapai ketersediaan tinggi, penskalaan anjal dan fungsi lain. Artikel ini memperkenalkan cara menggunakan Golang untuk membina kluster Docker.

1. Gambaran keseluruhan kluster Docker

Kluster Docker merujuk kepada berbilang hos Docker yang bekerjasama antara satu sama lain untuk mencapai fungsi seperti penggunaan aplikasi, pengurusan dan pemantauan. Kelompok Docker biasanya terdiri daripada konsep asas berikut:

1. Hos Docker

Hos Docker merujuk kepada komputer atau mesin maya yang menjalankan enjin Docker. Setiap hos Docker boleh menggunakan dan menjalankan berbilang bekas Docker.

2. Docker Swarm

Docker Swarm ialah alat orkestrasi kontena yang disediakan secara rasmi oleh Docker Ia boleh mengurus bekas pada berbilang hos Docker dan mencapainya dengan mentakrifkan konsep seperti perkhidmatan dan tugasan dan pengurusan aplikasi.

3. Perkhidmatan

Perkhidmatan ialah sekumpulan bekas dalam gugusan Docker dengan fungsi dan spesifikasi biasa, seperti perkhidmatan web, perkhidmatan pangkalan data, dsb. Perkhidmatan boleh menentukan berbilang contoh replika untuk mencapai fungsi seperti ketersediaan tinggi dan pengimbangan beban.

4. Task

Task ialah contoh Perkhidmatan, iaitu, bekas yang dijalankan pada hos Docker tertentu. Tugas boleh dijadualkan dan diurus oleh Docker Swarm untuk merealisasikan penggunaan automatik dan pengurusan kontena.

5. Node

Node ialah hos Docker dalam kelompok Docker dan boleh menjalankan berbilang Tugas dan Perkhidmatan.

2. Golang melaksanakan Docker Swarm

Docker Swarm menyediakan RESTful API dan alatan CLI untuk mengurus dan mengawal kelompok Docker. Golang, sebagai bahasa pengaturcaraan yang cekap, serentak, merentas platform, digunakan secara meluas dalam pengaturcaraan sistem dan pengaturcaraan rangkaian. Berikut menerangkan cara menggunakan Golang untuk melaksanakan fungsi asas Docker Swarm.

1. Pasang Docker SDK untuk Golang

Docker SDK untuk Golang ialah klien rasmi yang disediakan oleh Docker dan boleh berkomunikasi dengan mudah dengan pelayan Docker. SDK Docker untuk Golang boleh dipasang menggunakan arahan berikut:

go get -u github.com/docker/docker/client

2. Melaksanakan enkapsulasi Docker Swarm API

API Docker Swarm boleh dipanggil melalui permintaan HTTP dan mengembalikan data dalam JSON format. Kita boleh menggunakan Golang untuk merangkum API Docker Swarm untuk panggilan yang cepat dan mudah. Sebagai contoh, tentukan struktur berikut:

type SwarmClient struct {
    cli *client.Client
    ctx context.Context
}

type SwamService struct {
    ID string `json:"ID"`
    Name string `json:"Name"`
    Endpoint Endpoint `json:"Endpoint"`
}

type Endpoint struct {
    Spec EndpointSpec `json:"Spec"`
}

type EndpointSpec struct {
    Ports []PortConfig `json:"Ports"`
}

type PortConfig struct {
    Protocol string `json:"Protocol"`
    TargetPort uint32 `json:"TargetPort"`
    PublishedPort uint32 `json:"PublishedPort"`
}

Kami boleh menggunakan pakej HTTP Golang untuk melaksanakan operasi permintaan HTTP yang sepadan seperti GET, POST, PUT dan DELETE.

3. Melaksanakan alat Docker Swarm CLI

Selain menggunakan panggilan API RESTful, kami juga boleh melaksanakan alat Docker Swarm CLI untuk menjadikan kluster Docker Swarm pengurusan lebih intuitif dan operasi. Sebagai contoh, laksanakan arahan berikut:

docker-swarm service create [OPTIONS] IMAGE [COMMAND] [ARG...]

Arahan ini boleh mencipta perkhidmatan Perkhidmatan menggunakan imej dan parameter arahan yang ditentukan. Kita boleh menggunakan Golang untuk melaksanakan operasi yang sepadan, contohnya:

func createService(image string, command []string, port uint32)  {
    service := &swarm.ServiceSpec{
        TaskTemplate: swarm.TaskSpec{
            ContainerSpec: swarm.ContainerSpec{
                Image: image,
                Command: command,
                Env: []string{"PORT=" + strconv.Itoa(int(port))},
            },
        },
        EndpointSpec: &swarm.EndpointSpec{
            Ports: []swarm.PortConfig{
                swarm.PortConfig{
                    Protocol:      swarm.PortConfigProtocolTCP,
                    TargetPort:    uint32(port),
                    PublishedPort: uint32(port),
                },
            },
        },
    }

    cli, ctx := initCli()
    serviceCreateResponse, err := cli.ServiceCreate(ctx, *service, types.ServiceCreateOptions{})
    if err != nil {
        panic(err)
    }
}

Fungsi ini boleh menggunakan Docker SDK untuk Golang untuk mencipta perkhidmatan Perkhidmatan dan menentukan parameter seperti imej, arahan dan port.

4. Melaksanakan pemantauan dan pengelogan kluster Docker Swarm

Semasa menjalankan kluster Docker Swarm, kita perlu memantaunya dalam masa nyata dan melihat log. Kami boleh menggunakan Golang untuk melaksanakan program yang sepadan dan mendapatkan status kluster dan log kontena dengan menggunakan API yang disediakan dalam Docker SDK untuk Golang. Contohnya:

func listServices() {
    cli, ctx := initCli()
    services, err := cli.ServiceList(ctx, types.ServiceListOptions{})
    if err != nil {
        panic(err)
    }
    for _, service := range services {
        fmt.Printf("[Service] ID:%s Name:%s
", service.ID, service.Spec.Name)
    }
}

func getServiceLogs(serviceID string) {
    cli, ctx := initCli()
    reader, err := cli.ServiceLogs(ctx, serviceID, types.ContainerLogsOptions{})
    if err != nil {
        panic(err)
    }
    defer reader.Close()
    scanner := bufio.NewScanner(reader)
    for scanner.Scan() {
        fmt.Println(scanner.Text())
    }
}

Kod di atas melaksanakan operasi seperti mendapatkan senarai Perkhidmatan dalam kelompok Docker Swarm dan mendapatkan log Perkhidmatan yang ditentukan.

3. Gunakan Docker Compose untuk melaksanakan kelompok Docker Swarm

Docker Compose ialah alat orkestrasi kontena yang disediakan oleh Docker, yang boleh mengurus berbilang bekas dan perkhidmatan dengan mentakrifkan fail karang. Kita boleh menggunakan Docker Compose untuk membina dan mengurus kluster Docker Swarm dengan cepat. Sebagai contoh, takrifkan fail karang berikut:

version: '3'
services:
  web:
    image: nginx
    deploy:
      mode: replicated
      replicas: 3
      resources:
        limits:
          cpus: "0.1"
          memory: 50M
        reservations:
          cpus: "0.05"
          memory: 30M
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
    ports:
      - "80:80"
    networks:
      - webnet
  visualizer:
    image: dockersamples/visualizer:stable
    ports:
      - "8080:8080"
    stop_grace_period: 30s
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    deploy:
      placement:
        constraints: [node.role == manager]
    networks:
      - webnet

networks:
  webnet:

Fail karang ini mentakrifkan perkhidmatan web dan alat visualisasi, menggunakan imej nginx dan imej dockersamples/visualizer sebagai perkhidmatan. Antaranya, mod penggunaan perkhidmatan Web ialah kaedah penggunaan perkhidmatan yang direplikasi, yang akan menggunakan 3 contoh replika, dan menetapkan had sumber CPU dan memori, dasar mulakan semula dan konfigurasi lain. Alat visualisasi menggunakan nod hos Docker dengan node.role sebagai pengurus sebagai nod penempatan untuk melihat status kluster Docker Swarm dengan mudah.

Kita boleh menggunakan arahan berikut untuk memulakan Docker Compose:

docker stack deploy -c docker-compose.yml webapp

Arahan ini akan mencipta contoh Perkhidmatan dan Tugasan yang sepadan berdasarkan item konfigurasi yang ditakrifkan dalam fail karang, dan memulakan Docker Swarm kelompok. Kita boleh melihat status masa nyata kluster Docker Swarm dengan mengakses http://localhost:8080.

Ringkasan

Artikel ini memperkenalkan cara menggunakan Golang untuk melaksanakan fungsi asas kluster Docker Swarm dan cara menggunakan Docker Compose untuk membina dan mengurus kluster Docker Swarm dengan cepat. Dalam aplikasi praktikal, kluster Docker Swarm boleh menyediakan ketersediaan tinggi, penskalaan anjal dan fungsi lain, serta boleh mencapai pengurusan dan penggunaan aplikasi kontena yang cekap.

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