Go-യിൽ ഡോക്കർ കണ്ടെയ്‌നറുകൾ നിയന്ത്രിക്കുന്നു

പ്രമാണീകരണം!

സെർവറിലെ കണ്ടെയ്‌നറുകൾ സ്വയമേവ അപ്‌ഡേറ്റ്/റൺ ചെയ്യുന്നതിനായി ഡോക്കർ ഹബ്ബിൽ നിന്നോ രജിസ്ട്രിയിൽ നിന്നോ കൊളുത്തുകൾ പിടിക്കാൻ നിങ്ങളുടെ സ്വന്തം ബൈക്ക് എഴുതാൻ നിങ്ങൾ തീരുമാനിക്കുമ്പോൾ, ഡോക്കർ ക്ലി ഉപയോഗപ്രദമാണെന്ന് നിങ്ങൾ കണ്ടെത്തിയേക്കാം, ഇത് നിങ്ങളുടെ സിസ്റ്റത്തിലെ ഡോക്കർ ഡെമൺ നിയന്ത്രിക്കാൻ സഹായിക്കും.

പ്രവർത്തിക്കാൻ നിങ്ങൾക്ക് 1.9.4-ൽ കുറയാത്ത Go പതിപ്പ് ആവശ്യമാണ്

നിങ്ങൾ ഇപ്പോഴും മൊഡ്യൂളുകളിലേക്ക് മാറിയിട്ടില്ലെങ്കിൽ, ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച് Cli ഇൻസ്റ്റാൾ ചെയ്യുക:

go get github.com/docker/docker/client

ഒരു കണ്ടെയ്നർ പ്രവർത്തിപ്പിക്കുന്നു

ഡോക്കർ API ഉപയോഗിച്ച് ഒരു കണ്ടെയ്‌നർ എങ്ങനെ പ്രവർത്തിപ്പിക്കാമെന്ന് ഇനിപ്പറയുന്ന ഉദാഹരണം കാണിക്കുന്നു. കമാൻഡ് ലൈനിൽ നിങ്ങൾ കമാൻഡ് ഉപയോഗിക്കും docker run, എന്നാൽ ഞങ്ങളുടെ സേവനത്തിൽ ഈ ടാസ്ക്കിനെ എളുപ്പത്തിൽ നേരിടാൻ കഴിയും.
ഈ ഉദാഹരണം കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നതിന് തുല്യമാണ് docker run alpine echo hello world

package main {
    ctx := context.Background()
    cli, err := client.NewEnvClient()
    if err != nil {
        panic(err)
    }

    // Делаем docker pull
    reader, err := cli.ImagePull(ctx, "docker.io/library/alpine", types.ImagePullOptions{})
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, reader)

    hostBinding := nat.PortBinding{
        HostIP:   "0.0.0.0",
        HostPort: "8000",
    }
    containerPort, err := nat.NewPort("tcp", "80")
    if err != nil {
        panic("Unable to get the port")
    }
    portBinding := nat.PortMap{containerPort: []nat.PortBinding{hostBinding}}

    // Создаем контейнер с заданной конфигурацией
    resp, err := cli.ContainerCreate(ctx, &container.Config{
        Image: "alpine",
        Cmd:   []string{"echo", "hello world"},
        Tty:   true,
    }, &container.HostConfig{
        PortBindings: portBinding,
    }, nil, "")
    if err != nil {
        panic(err)
    }

    // Запускаем контейнер
    if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
        panic(err)
    }

    // Получаем логи контейнера
    out, err := cli.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true})
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, out)
}

പ്രവർത്തിക്കുന്ന കണ്ടെയ്‌നറുകളുടെ ഒരു ലിസ്റ്റ് ലഭിക്കുന്നു

ഈ ഉദാഹരണം കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നതിന് തുല്യമാണ് docker ps

package main

import (
    "context"
    "fmt"

    "github.com/docker/docker/api/types"
    "github.com/docker/docker/client"
)

func main() {
    cli, err := client.NewEnvClient()
    if err != nil {
        panic(err)
    }

    // Получение списка запуцщенных контейнеров(docker ps)
    containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    // Вывод всех идентификаторов контейнеров
    for _, container := range containers {
        fmt.Println(container.ID)
    }
}

ഓടുന്ന എല്ലാ പാത്രങ്ങളും നിർത്തുന്നു

കണ്ടെയ്‌നറുകൾ എങ്ങനെ സൃഷ്ടിക്കാമെന്നും പ്രവർത്തിപ്പിക്കാമെന്നും നിങ്ങൾ പഠിച്ചുകഴിഞ്ഞാൽ, അവ എങ്ങനെ കൈകാര്യം ചെയ്യണമെന്ന് പഠിക്കാനുള്ള സമയമാണിത്. ഇനിപ്പറയുന്ന ഉദാഹരണം എല്ലാ പ്രവർത്തിക്കുന്ന കണ്ടെയ്‌നറുകളും നിർത്തും.

ഒരു പ്രൊഡക്ഷൻ സെർവറിൽ ഈ കോഡ് പ്രവർത്തിപ്പിക്കരുത്!

package main

import (
    "context"
    "fmt"

    "github.com/docker/docker/api/types"
    "github.com/docker/docker/client"
)

func main() {
    ctx := context.Background()
    cli, err := client.NewEnvClient()
    if err != nil {
        panic(err)
    }

    // Получение списка запуцщенных контейнеров(docker ps)
    containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    for _, c := range containers {
        fmt.Print("Stopping container ", c.ID[:10], "... ")
        if err := cli.ContainerStop(ctx, c.ID, nil); err != nil {
            panic(err)
        }
        fmt.Println("Success")
    }
}

ഒരൊറ്റ കണ്ടെയ്‌നറിനായി ലോഗുകൾ പ്രദർശിപ്പിക്കുന്നു

നിങ്ങൾക്ക് വ്യക്തിഗത കണ്ടെയ്നറുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കാം. ഇനിപ്പറയുന്ന ഉദാഹരണം നിർദ്ദിഷ്ട ഐഡൻ്റിഫയർ ഉപയോഗിച്ച് കണ്ടെയ്നർ ലോഗുകൾ പ്രദർശിപ്പിക്കുന്നു. ആരംഭിക്കുന്നതിന് മുമ്പ്, നിങ്ങൾക്ക് ലഭിക്കാൻ ആഗ്രഹിക്കുന്ന ലോഗുകളുടെ കണ്ടെയ്‌നറിൻ്റെ ഐഡി മാറ്റേണ്ടതുണ്ട്.

package main

import (
    "context"
    "io"
    "os"

    "github.com/docker/docker/api/types"
    "github.com/docker/docker/client"
)

func main() {
    ctx := context.Background()
    cli, err := client.NewEnvClient()
    if err != nil {
        panic(err)
    }

    options := types.ContainerLogsOptions{ShowStdout: true}
    // Измените id контейнера здесь
    out, err := cli.ContainerLogs(ctx, "f1064a8a4c82", options)
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, out)
}

ചിത്രങ്ങളുടെ ഒരു ലിസ്റ്റ് ലഭിക്കുന്നു

ഈ ഉദാഹരണം കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നതിന് തുല്യമാണ് docker image ls

package main

import (
    "context"
    "fmt"

    "github.com/docker/docker/api/types"
    "github.com/docker/docker/client"
)

func main() {
    cli, err := client.NewEnvClient()
    if err != nil {
        panic(err)
    }

    // Получение списка образов
    images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
    if err != nil {
        panic(err)
    }

    for _, image := range images {
        fmt.Println(image.ID)
    }
}

വലിക്കുക

ഈ ഉദാഹരണം കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നതിന് തുല്യമാണ് docker pull

package main

import (
    "context"
    "io"
    "os"

    "github.com/docker/docker/api/types"
    "github.com/docker/docker/client"
)

func main() {
    ctx := context.Background()
    cli, err := client.NewEnvClient()
    if err != nil {
        panic(err)
    }

    // docker pull alpine
    out, err := cli.ImagePull(ctx, "docker.io/library/alpine", types.ImagePullOptions{})
    if err != nil {
        panic(err)
    }
    defer out.Close()
    io.Copy(os.Stdout, out)
}

ഉപയോക്തൃ പ്രാമാണീകരണത്തോടെ ഒരു ചിത്രം ഡൗൺലോഡ് ചെയ്യുന്നു

ഈ ഉദാഹരണം കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നതിന് തുല്യമാണ് docker pull, ആധികാരികതയോടെ.

പ്രാമാണീകരണ ഡാറ്റ വ്യക്തമായ വാചകത്തിൽ അയച്ചു. ഔദ്യോഗിക ഡോക്കർ രജിസ്ട്രി HTTPS ഉപയോഗിക്കുന്നു,
HTTPS ഉപയോഗിച്ച് ഡാറ്റ കൈമാറാൻ സ്വകാര്യ രജിസ്ട്രികളും കോൺഫിഗർ ചെയ്തിരിക്കണം.

package main

import (
    "context"
    "encoding/base64"
    "encoding/json"
    "io"
    "os"

    "github.com/docker/docker/api/types"
    "github.com/docker/docker/client"
)

func main() {
    ctx := context.Background()
    cli, err := client.NewEnvClient()
    if err != nil {
        panic(err)
    }

    // Создание конфига с данными для аутентификации
    authConfig := types.AuthConfig{
        Username: "username",
        Password: "password",
    }
    encodedJSON, err := json.Marshal(authConfig)
    if err != nil {
        panic(err)
    }
    authStr := base64.URLEncoding.EncodeToString(encodedJSON)

    out, err := cli.ImagePull(ctx, "docker.io/library/alpine", types.ImagePullOptions{RegistryAuth: authStr})
    if err != nil {
        panic(err)
    }

    defer out.Close()
    io.Copy(os.Stdout, out)
}

അവലംബം: www.habr.com