ื ื™ื”ื•ืœ ืงื•ื ื˜ื™ื™ื ืจื™ื ืฉืœ Docker ื‘-Go

ืชื™ืขื•ื“!

ื›ืืฉืจ ืืชื” ืžื—ืœื™ื˜ ืœื›ืชื•ื‘ ืื•ืคื ื™ื™ื ืžืฉืœืš ืœืชืคื™ืกืช ื•ื•ื™ื ืžืžืจื›ื– ื”- Docker ืื• ืžื”ืจื™ืฉื•ื ื›ื“ื™ ืœืขื“ื›ืŸ/ืœื”ืคืขื™ืœ ืื•ื˜ื•ืžื˜ื™ืช ืงื•ื ื˜ื™ื™ื ืจื™ื ื‘ืฉืจืช, ื™ื™ืชื›ืŸ ืฉืชืžืฆื ืืช ื”- Docker Cli ืฉื™ืžื•ืฉื™, ืฉื™ืขื–ื•ืจ ืœื ื”ืœ ืืช ื”ื“ืžื•ืŸ Docker ื‘ืžืขืจื›ืช ืฉืœืš.
ื ื™ื”ื•ืœ ืงื•ื ื˜ื™ื™ื ืจื™ื ืฉืœ Docker ื‘-Go

ื›ื“ื™ ืœืขื‘ื•ื“ ืชื–ื“ืงืง ืœื’ืจืกืช Go ืœื ื ืžื•ื›ื” ืž-1.9.4

ืื ืขื“ื™ื™ืŸ ืœื ืขื‘ืจืช ืœืžื•ื“ื•ืœื™ื, ื”ืชืงืŸ ืืช Cli ืขื ื”ืคืงื•ื“ื” ื”ื‘ืื”:

go get github.com/docker/docker/client

ื”ืคืขืœืช ืžื™ื›ืœ

ื”ื“ื•ื’ืžื” ื”ื‘ืื” ืžืจืื” ื›ื™ืฆื“ ืœื”ืคืขื™ืœ ืงื•ื ื˜ื™ื™ื ืจ ื‘ืืžืฆืขื•ืช Docker 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

ื”ื•ืกืคืช ืชื’ื•ื‘ื”