Quando deciderai di scrivere il tuo lavoro sui ganci per il recupero da docker hub o da registry per l'aggiornamento/avvio automatico dei contenitori sul server, potresti aver bisogno di Docker Cli, che ti aiuterà a gestire il demone Docker nel tuo sistema.
Per farlo, avrai bisogno di Go versione 1.9.4 o superiore.
Se non hai ancora fatto il passaggio ai moduli, installa Cli con il seguente comando:
go get github.com/docker/docker/clientAvvio del contenitore
Il seguente esempio mostra come avviare un contenitore utilizzando l'API Docker. Nella riga di comando utilizzeresti il comando docker run, ma noi possiamo facilmente gestire questa operazione nel nostro servizio.
Questo esempio è equivalente all'esecuzione del comando docker run alpine echo hello world
package main {
ctx := context.Background()
cli, err := client.NewEnvClient()
if err != nil {
panic(err)
}
// Eseguiamo 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("Impossibile ottenere la porta")
}
portBinding := nat.PortMap{containerPort: []nat.PortBinding{hostBinding}}
// Creiamo un contenitore con la configurazione specificata
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)
}
// Avviamo il contenitore
if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
panic(err)
}
// Otteniamo i log del contenitore
out, err := cli.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true})
if err != nil {
panic(err)
}
io.Copy(os.Stdout, out)
}Recupero dell'elenco dei contenitori in esecuzione
Questo esempio è equivalente all'esecuzione del comando 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)
}
// Recupero dell'elenco dei contenitori in esecuzione (docker ps)
containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
if err != nil {
panic(err)
}
// Stampa di tutti gli identificatori dei contenitori
for _, container := range containers {
fmt.Println(container.ID)
}
}
Arresto di tutti i contenitori in esecuzione
Dopo aver imparato a creare e avviare contenitori, è tempo di imparare a gestirli. Il seguente esempio fermerà tutti i contenitori in esecuzione.
Non eseguire questo codice in produzione server!
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)
}
// Ottenere la lista dei contenitori in esecuzione (docker ps)
containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
if err != nil {
panic(err)
}
for _, c := range containers {
fmt.Print("Arresto del contenitore ", c.ID[:10], "... ")
if err := cli.ContainerStop(ctx, c.ID, nil); err != nil {
panic(err)
}
fmt.Println("Successo")
}
}Visualizzazione dei log di un singolo contenitore
È possibile lavorare con contenitori singoli. Nel seguente esempio vengono visualizzati i log del contenitore con l'identificativo specificato. Prima di eseguire, è necessario modificare l'identificativo del contenitore di cui si desidera ottenere i log.
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}
// Modifica qui l'id del contenitore
out, err := cli.ContainerLogs(ctx, "f1064a8a4c82", options)
if err != nil {
panic(err)
}
io.Copy(os.Stdout, out)
}Ottenere la lista delle immagini
Questo esempio è equivalente all'esecuzione del comando 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)
}
// Ottenere la lista delle immagini
images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
if err != nil {
panic(err)
}
for _, image := range images {
fmt.Println(image.ID)
}
}
Pull
Questo esempio è equivalente all'esecuzione del comando 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)
}
Scaricare l'immagine con autenticazione utente
Questo esempio è equivalente all'esecuzione del comando docker pull, con autenticazione.
I dati di autenticazione vengono inviati in chiaro. I registry ufficiali di Docker utilizzano HTTPS,
anche i registry privati devono essere configurati per trasmettere i dati utilizzando 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)
}
// Creazione della configurazione con i dati per l'autenticazione
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)
}Fonte: habr.com
