Quando deciderai di scrivere il tuo container per il recupero di hook da docker hub o da registry per l'aggiornamento automatico/avvio di container sul server, Docker CLI potrebbe esserti utile per gestire il demone Docker nel tuo sistema.
Per lavorare avrai bisogno di Go versione non inferiore a 1.9.4
Se non hai ancora abilitato i moduli, installa CLI con il seguente comando:
go get github.com/docker/docker/clientAvvio del contenitore
Il seguente esempio mostra come avviare un container utilizzando l'API Docker. Nella riga di comando utilizzeresti il comando docker run, ma noi gestiremo facilmente questo compito 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 container 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 container
if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
panic(err)
}
// Otteniamo i log del container
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 container 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 container in esecuzione (docker ps)
containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
if err != nil {
panic(err)
}
// Stampa di tutti gli ID dei container
for _, container := range containers {
fmt.Println(container.ID)
}
}
Arresto di tutti i container in esecuzione
Dopo aver imparato a creare e avviare container, è tempo di imparare a gestirli. Il seguente esempio fermerà tutti i container 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)
}
// Recupero dell'elenco dei container in esecuzione (docker ps)
containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
if err != nil {
panic(err)
}
for _, c := range containers {
fmt.Print("Arrestando il container ", c.ID[:10], "... ")
if err := cli.ContainerStop(ctx, c.ID, nil); err != nil {
panic(err)
}
fmt.Println("Successo")
}
}Visualizzazione dei log di un singolo container
Puoi lavorare con singoli container. Nel seguente esempio vengono visualizzati i log per il container con l'ID specificato. Prima di eseguirlo, dovrai modificare l'ID del container i cui log desideri ottenere.
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 container
out, err := cli.ContainerLogs(ctx, "f1064a8a4c82", options)
if err != nil {
panic(err)
}
io.Copy(os.Stdout, out)
}Recupero dell'elenco 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)
}
// Recupero dell'elenco 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)
}
Scaricamento di un'immagine con autenticazione utente
Questo esempio è equivalente all'esecuzione del comando docker pull, con autenticazione.
I dati di autenticazione vengono inviati in chiaro. Le registrazioni ufficiali di Docker utilizzano HTTPS,
le registrazioni private devono essere configurate per trasmettere 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 di una configurazione con i dati di 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
