Kur të vendosni të shkruani, biçikletën tuaj për kapjen e hook-ëve nga docker hub ose nga registry për azhurnimin/e nisjen automatike të kontejnerëve në server, Docker Cli mund t'ju ndihmojë në menaxhimin e demonit Docker në sistemin tuaj.
Për punë do të nevojitet Go versioni jo më i ulët se 1.9.4.
Nëse akoma nuk keni kaluar në module, instaloni CLI me komandën në vijim:
go get github.com/docker/docker/clientNisja e kontejnerit
Shembulli në vijim tregon si të nisni një kontejner duke përdorur Docker API. Në vijën e komandës do të përdornit komandën docker run, por ne do ta realizojmë këtë detyrë pa ndonjë vështirësi në shërbimin tonë.
Ky shembull është ekuivalent me ekzekutimin e komandës docker run alpine echo hello world
package main {
ctx := context.Background()
cli, err := client.NewEnvClient()
if err != nil {
panic(err)
}
// Bëjmë 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("E pamundur të marrim portin")
}
portBinding := nat.PortMap{containerPort: []nat.PortBinding{hostBinding}}
// Krijojmë një kontejner me konfigurimin e caktuar
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)
}
// Nisim kontejnerin
if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
panic(err)
}
// Marrim loget e kontejnerit
out, err := cli.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true})
if err != nil {
panic(err)
}
io.Copy(os.Stdout, out)
}Marrja e listës së kontejnerëve të nisur
Ky shembull është ekuivalent me ekzekutimin e komandës 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)
}
// Marrja e listës së kontejnerëve të nisur (docker ps)
containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
if err != nil {
panic(err)
}
// Shfaqja e të gjithë identifikuesve të kontejnerëve
for _, container := range containers {
fmt.Println(container.ID)
}
}
Ndalo të gjithë kontejnerët e nisur
Pasi të keni mësuar të krijoni dhe nisni kontejnerë, është koha të mësoni se si t'i menaxhoni ata. Shembulli në vijim do të ndalë të gjithë kontejnerët e nisur.
Mos e ekzekutoni këtë kod në prodhim. server!
paketa kryesore
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)
}
// Marrja e listës së konteinerëve të ndezur (docker ps)
containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
if err != nil {
panic(err)
}
for _, c := range containers {
fmt.Print("Stopimi i konteinerit ", c.ID[:10], "... ")
if err := cli.ContainerStop(ctx, c.ID, nil); err != nil {
panic(err)
}
fmt.Println("Sukses")
}
}Shfaqja e regjistrimeve të një konteineri të veçantë
Mund të punoni me konteinerë të veçantë. Në shembullin vijues shfaqen regjistrimet e konteinerit me identifikuesin e dhënë. Para se të ekzekutoni, duhet të ndryshoni identifikuesin e konteinerit për të cilin dëshironi të merrni regjistrimet.
paketa kryesore
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}
// Ndryshoni id e konteinerit këtu
out, err := cli.ContainerLogs(ctx, "f1064a8a4c82", options)
if err != nil {
panic(err)
}
io.Copy(os.Stdout, out)
}Marrja e listës së imazheve
Ky shembull është ekuivalent me ekzekutimin e komandës docker image ls
paketa kryesore
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)
}
// Marrja e listës së imazheve
images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
if err != nil {
panic(err)
}
for _, image := range images {
fmt.Println(image.ID)
}
}
TĂ«rheqje
Ky shembull është ekuivalent me ekzekutimin e komandës docker pull
paketa kryesore
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)
}
Shkarkimi i imazhit me autentifikim të përdoruesit
Ky shembull është ekuivalent me ekzekutimin e komandës docker pull, me autentifikim.
Të dhënat e autentifikimit dërgohen në formë të qartë. Regjistrat zyrtarë të docker përdorin HTTPS,
regjistrat privat gjithashtu duhet të jenë të konfiguruar për të dërguar të dhënat duke përdorur 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)
}
// Krijimi i konfigurimit me të dhënat për autentikimin
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)
}Burimi: habr.com
