рдЬрдм рддрдкрд╛рдЗрдБ рдбрдХрд░ рд╣рдмрдмрд╛рдЯ рд╣реБрдХрд╣рд░реВ рд╕рдорд╛рддреНрди рд╡рд╛ рд╕рд░реНрднрд░рдорд╛ рдХрдиреНрдЯреЗрдирд░рд╣рд░реВ рд╕реНрд╡рдЪрд╛рд▓рд┐рдд рд░реВрдкрдорд╛ рдЕрджреНрдпрд╛рд╡рдзрд┐рдХ рдЧрд░реНрди / рдЪрд▓рд╛рдЙрдирдХреЛ рд▓рд╛рдЧрд┐ рд░рдЬрд┐рд╕реНрдЯреНрд░реАрдмрд╛рдЯ рдЖрдлреНрдиреИ рдмрд╛рдЗрдХ рд▓реЗрдЦреНрдиреЗ рдирд┐рд░реНрдгрдп рдЧрд░реНрдиреБрд╣реБрдиреНрдЫ, рддрдкрд╛рдЗрдБрд▓реЗ рдбрдХрд░ рдХреНрд▓реА рдЙрдкрдпреЛрдЧреА рдкрд╛рдЙрди рд╕рдХреНрдиреБрд╣реБрдиреНрдЫ, рдЬрд╕рд▓реЗ рддрдкрд╛рдЗрдБрдХреЛ рдкреНрд░рдгрд╛рд▓реАрдорд╛ рдбрдХрд░ рдбреЗрдорди рд╡реНрдпрд╡рд╕реНрдерд╛рдкрди рдЧрд░реНрди рдорджреНрджрдд рдЧрд░реНрджрдЫред
рдХрд╛рдо рдЧрд░реНрдирдХреЛ рд▓рд╛рдЧрд┐ рддрдкрд╛рдИрдВрд▓рд╛рдИ 1.9.4 рднрдиреНрджрд╛ рдХрдо Go рд╕рдВрд╕реНрдХрд░рдг рдЖрд╡рд╢реНрдпрдХ рдкрд░реНрдиреЗрдЫ
рдпрджрд┐ рддрдкрд╛рдИрдВрд▓реЗ рдЕрдЭреИ рдореЛрдбреНрдпреБрд▓рд╣рд░реВрдорд╛ рд╕реНрд╡рд┐рдЪ рдЧрд░реНрдиреБрднрдПрдХреЛ рдЫреИрди рднрдиреЗ, рдирд┐рдореНрди рдЖрджреЗрд╢рдХреЛ рд╕рд╛рде Cli рд╕реНрдерд╛рдкрдирд╛ рдЧрд░реНрдиреБрд╣реЛрд╕реН:
go get github.com/docker/docker/client
рдХрдиреНрдЯреЗрдирд░ рдЪрд▓рд╛рдЙрдБрджреИ
рдирд┐рдореНрди рдЙрджрд╛рд╣рд░рдгрд▓реЗ рдбрдХрд░ рдПрдкреАрдЖрдИ рдкреНрд░рдпреЛрдЧ рдЧрд░реЗрд░ рдХрдиреНрдЯреЗрдирд░ рдХрд╕рд░реА рдЪрд▓рд╛рдЙрдиреЗ рднрдиреЗрд░ рджреЗрдЦрд╛рдЙрдБрдЫред рдЖрджреЗрд╢ рд░реЗрдЦрд╛рдорд╛ рддрдкрд╛рдИрдВрд▓реЗ рдЖрджреЗрд╢ рдкреНрд░рдпреЛрдЧ рдЧрд░реНрдиреБрд╣реБрдиреЗрдЫ 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