Go āĻ āĻĄāĻ•āĻžāϰ āĻ•āĻ¨ā§āĻŸā§‡āχāύāĻžāϰ āĻĒāϰāĻŋāϚāĻžāϞāύāĻž āĻ•āϰāĻž

āĻĄāϕ⧁āĻŽā§‡āĻ¨ā§āĻŸā§‡āĻļāύ !

āφāĻĒāύāĻŋ āϝāĻ–āύ āĻĄāĻ•āĻžāϰ āĻšāĻžāĻŦ āĻĨ⧇āϕ⧇ āĻšā§āĻ• āϧāϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦāĻž āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ āĻ•āύāĻŸā§‡āχāύāĻžāϰāϗ⧁āϞāĻŋāϕ⧇ āĻ¸ā§āĻŦāϝāĻŧāĻ‚āĻ•ā§āϰāĻŋāϝāĻŧāĻ­āĻžāĻŦ⧇ āφāĻĒāĻĄā§‡āϟ/āϚāĻžāϞāĻžāύ⧋āϰ āϜāĻ¨ā§āϝ āϰ⧇āϜāĻŋāĻ¸ā§āĻŸā§āϰāĻŋ āĻĨ⧇āϕ⧇ āφāĻĒāύāĻžāϰ āύāĻŋāĻœā§‡āϰ āĻŦāĻžāχāĻ• āϞ⧇āĻ–āĻžāϰ āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āύ⧇āύ, āϤāĻ–āύ āφāĻĒāύāĻŋ āĻĄāĻ•āĻžāϰ āĻ•ā§āϞāĻŋāϟāĻŋāϕ⧇ āĻĻāϰāĻ•āĻžāϰ⧀ āĻŦāϞ⧇ āĻŽāύ⧇ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āύ, āϝāĻž āφāĻĒāύāĻžāϰ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡ āĻĄāĻ•āĻžāϰ āĻĄā§‡āĻŽāύ āĻĒāϰāĻŋāϚāĻžāϞāύāĻž āĻ•āϰāϤ⧇ āϏāĻšāĻžāϝāĻŧāϤāĻž āĻ•āϰāĻŦ⧇⧎
Go āĻ āĻĄāĻ•āĻžāϰ āĻ•āĻ¨ā§āĻŸā§‡āχāύāĻžāϰ āĻĒāϰāĻŋāϚāĻžāϞāύāĻž āĻ•āϰāĻž

āĻ•āĻžāϜ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āφāĻĒāύāĻžāϰ āĻ—ā§‹ āĻ­āĻžāĻ°ā§āϏāύ 1.9.4 āĻāϰ āĻ•āĻŽ āύāϝāĻŧ

āφāĻĒāύāĻŋ āϝāĻĻāĻŋ āĻāĻ–āύāĻ“ āĻŽāĻĄāĻŋāωāϞāϗ⧁āϞāĻŋāϤ⧇ āĻ¸ā§āϝ⧁āχāϚ āύāĻž āĻ•āϰ⧇ āĻĨāĻžāϕ⧇āύ āϤāĻŦ⧇ āύāĻŋāĻŽā§āύāϞāĻŋāĻ–āĻŋāϤ āĻ•āĻŽāĻžāĻ¨ā§āĻĄāϟāĻŋ āĻĻāĻŋāϝāĻŧ⧇ 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

DDoS āϏ⧁āϰāĻ•ā§āώāĻž, VPS VDS āϏāĻžāĻ°ā§āĻ­āĻžāϰ āϏāĻš āϏāĻžāχāϟāϗ⧁āϞāĻŋāϰ āϜāĻ¨ā§āϝ āύāĻŋāĻ°ā§āĻ­āϰāϝ⧋āĻ—ā§āϝ āĻšā§‹āĻ¸ā§āϟāĻŋāĻ‚ āĻ•āĻŋāύ⧁āύ đŸ”Ĩ DDoS āϏ⧁āϰāĻ•ā§āώāĻž āϏāĻš āύāĻŋāĻ°ā§āĻ­āϰāϝ⧋āĻ—ā§āϝ āĻ“āϝāĻŧ⧇āĻŦāϏāĻžāχāϟ āĻšā§‹āĻ¸ā§āϟāĻŋāĻ‚ āĻ•āĻŋāύ⧁āύ, VPS VDS āϏāĻžāĻ°ā§āĻ­āĻžāϰ | ProHoster