เจเจฆเฉเจ เจคเฉเจธเฉเจ เจกเฉเจเจฐ เจนเฉฑเจฌ เจคเฉเจ เจเจพเจ เจฐเจเจฟเจธเจเจฐเฉ เจคเฉเจ เจธเจฐเจตเจฐ 'เจคเฉ เจเฉฐเจเฉเจจเจฐเจพเจ เจจเฉเฉฐ เจเจเฉเจฎเฉเจเจฟเจ เจ
เฉฑเจชเจกเฉเจ/เจฐเจจ เจเจฐเจจ เจฒเจ เจนเฉเฉฑเจเจพเจ เจจเฉเฉฐ เจซเฉเจจ เจฒเจ เจเจชเจฃเฉ เจเฉเจฆ เจฆเฉ เจธเจพเจเจเจฒ เจฒเจฟเจเจฃ เจฆเจพ เจซเฉเจธเจฒเจพ เจเจฐเจฆเฉ เจนเฉ, เจคเจพเจ เจคเฉเจนเจพเจจเฉเฉฐ เจกเฉเจเจฐ เจเจฒเฉ เจฒเจพเจญเจฆเจพเจเจ เจฒเฉฑเจ เจธเจเจฆเฉ เจนเฉ, เจเฉ เจคเฉเจนเจพเจกเฉ เจธเจฟเจธเจเจฎ 'เจคเฉ เจกเฉเจเจฐ เจกเฉเจฎเจจ เจฆเจพ เจชเฉเจฐเจฌเฉฐเจงเจจ เจเจฐเจจ เจตเจฟเฉฑเจ เจฎเจฆเจฆ เจเจฐเฉเจเฉเฅค
เจเฉฐเจฎ เจเจฐเจจ เจฒเจ เจคเฉเจนเจพเจจเฉเฉฐ 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