Gerenciando contêineres do Docker no Go

Documentação!

Quando você decide escrever sua própria bicicleta para capturar ganchos no hub do docker ou no registro para atualizar / iniciar automaticamente contêineres no servidor, pode ser necessário o Docker Cli, que ajudará a gerenciar o daemon do Docker no seu sistema.

Para funcionar, você precisará da versão Go não inferior a 1.9.4

Se você ainda não mudou para os módulos, instale o Cli com o seguinte comando:

go get github.com/docker/docker/client 

Lançamento de contêiner

O exemplo a seguir mostra como iniciar um contêiner usando a API do Docker. Na linha de comando, você usaria o docker run , mas podemos facilmente lidar com essa tarefa em nosso serviço.
Este exemplo é equivalente à execução do comando 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) } 

Obtendo uma lista de contêineres em execução

Este exemplo é equivalente à execução do 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) } } 

Pare todos os contêineres em execução

Depois de aprender como criar e executar contêineres, é hora de aprender a gerenciá-los. O exemplo a seguir irá parar todos os contêineres em execução.

Não execute esse código em um servidor de produção!

 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") } } 

Registrando um Único Contêiner

Você pode trabalhar com contêineres individuais. O exemplo a seguir exibe os logs do contêiner com o identificador especificado. Antes de iniciar, você precisa alterar o identificador do contêiner cujos logs você deseja receber.

 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) } 

Obtendo a lista de imagens

Este exemplo é equivalente à execução da 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) } } 

Pull

Este exemplo é equivalente à execução do docker pull do 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) } 

Baixar imagem com autenticação do usuário

Este exemplo é equivalente à execução do docker pull do docker pull com autenticação.

Os dados de autenticação são enviados em texto não criptografado. O registro oficial do docker usa HTTPS,
Os registros particulares também devem ser configurados para transmitir dados usando 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) }