рдЬреЗрд╡реНрд╣рд╛ рддреБрдореНрд╣реА рддреБрдордЪреА рд╕реНрд╡рдд:рдЪреА рдмрд╛рдИрдХ рдбреЙрдХрд░ рд╣рдмрдордзреВрди рдХрд┐рдВрд╡рд╛ рд╕рд░реНрд╡реНрд╣рд░рд╡рд░ рдХрдВрдЯреЗрдирд░ рд╕реНрд╡рдпрдВрдЪрд▓рд┐рддрдкрдгреЗ рдЕрдкрдбреЗрдЯ/рд░рди рдХрд░рдгреНрдпрд╛рд╕рд╛рдареА рд░реЗрдЬрд┐рд╕реНрдЯреНрд░реАрдордзреВрди рд╣реБрдХ рдкрдХрдбрдгреНрдпрд╛рд╕рд╛рдареА рд▓рд┐рд╣рд┐рдгреНрдпрд╛рдЪреЗ рдард░рд╡рддрд╛, рддреЗрд╡реНрд╣рд╛ рддреБрдореНрд╣рд╛рд▓рд╛ рдбреЙрдХрд░ рдХреНрд▓реА рдЙрдкрдпреБрдХреНрдд рд╡рд╛рдЯреВ рд╢рдХрддреЗ, рдЬреЗ рддреБрдордЪреНрдпрд╛ рд╕рд┐рд╕реНрдЯрдорд╡рд░ рдбреЙрдХрд░ рдбрд┐рдорди рд╡реНрдпрд╡рд╕реНрдерд╛рдкрд┐рдд рдХрд░рдгреНрдпрд╛рдд рдорджрдд рдХрд░реЗрд▓.
рдХрд╛рд░реНрдп рдХрд░рдгреНрдпрд╛рд╕рд╛рдареА рддреБрдореНрд╣рд╛рд▓рд╛ 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")
}
}
рдПрдХрд╛ рдХрдВрдЯреЗрдирд░рд╕рд╛рдареА рд▓реЙрдЧ рдкреНрд░рджрд░реНрд╢рд┐рдд рдХрд░рдгреЗ
рдЖрдкрдг рд╡реИрдпрдХреНрддрд┐рдХ рдХрдВрдЯреЗрдирд░рд╕рд╣ рдХрд╛рд░реНрдп рдХрд░реВ рд╢рдХрддрд╛. рдЦрд╛рд▓реАрд▓ рдЙрджрд╛рд╣рд░рдг рдирд┐рд░реНрджрд┐рд╖реНрдЯ рдЕрднрд┐рдЬреНрдЮрд╛рдкрдХрд╛рд╕рд╣ рдХрдВрдЯреЗрдирд░ рд▓реЙрдЧ рдкреНрд░рджрд░реНрд╢рд┐рдд рдХрд░рддреЗ. рд╕реБрд░реВ рдХрд░рдгреНрдпрд╛рдкреВрд░реНрд╡реА, рдЖрдкрдг рдЬреНрдпрд╛ рдХрдВрдЯреЗрдирд░рдЪреЗ рд▓реЙрдЧ рдкреНрд░рд╛рдкреНрдд рдХрд░реВ рдЗрдЪреНрдЫрд┐рддрд╛ рддреНрдпрд╛ рдХрдВрдЯреЗрдирд░рдЪрд╛ ID рдмрджрд▓рдгреЗ рдЖрд╡рд╢реНрдпрдХ рдЖрд╣реЗ.
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