Docker
API de Docker Engine

Introducción

Habilitar el acceso remoto a la API de Docker en Linux

Edite /etc/init/docker.conf y actualice la variable DOCKER_OPTS a lo siguiente:

DOCKER_OPTS='-H tcp://0.0.0.0:4243 -H unix:///var/run/docker.sock'

Reiniciar Docker Docker

service docker restart

Verificar si la API remota está funcionando

curl -X GET http://localhost:4243/images/json

Habilitar el acceso remoto a la API de Docker en Linux ejecutando systemd

Linux ejecutando systemd, como Ubuntu 16.04, agregar -H tcp://0.0.0.0:2375 a /etc/default/docker no tiene el efecto que solía tener.

En su lugar, cree un archivo llamado /etc/systemd/system/docker-tcp.socket para que la ventana acoplable esté disponible en un socket TCP en el puerto 4243:

[Unit]
Description=Docker Socket for the API  
[Socket]
ListenStream=4243  
Service=docker.service  
[Install]
WantedBy=sockets.target 

Entonces habilita el nuevo socket:

systemctl enable docker-tcp.socket
systemctl enable docker.socket
systemctl stop docker
systemctl start docker-tcp.socket
systemctl start docker

Ahora, verifique si la API remota está funcionando:

curl -X GET http://localhost:4243/images/json

Habilitar el acceso remoto con TLS en Systemd

Copie el archivo de la unidad del instalador de paquetes en / etc, donde los cambios no se sobrescribirán en una actualización:

cp /lib/systemd/system/docker.service /etc/systemd/system/docker.service

Actualice /etc/systemd/system/docker.service con sus opciones en ExecStart:

ExecStart=/usr/bin/dockerd -H fd:// -H tcp://0.0.0.0:2376 \
  --tlsverify --tlscacert=/etc/docker/certs/ca.pem \
  --tlskey=/etc/docker/certs/key.pem \
  --tlscert=/etc/docker/certs/cert.pem

Tenga en cuenta que dockerd es el nombre del daemon 1.12, antes de que fuera el docker daemon . También tenga en cuenta que 2376 es el puerto TLS estándar de los dockers, 2375 es el puerto no cifrado estándar. Consulte esta página para conocer los pasos para crear su propia CA, certificado y clave autofirmados por TLS.

Después de realizar cambios en los archivos de la unidad del sistema, ejecute lo siguiente para volver a cargar la configuración del sistema:

systemctl daemon-reload

Y luego ejecuta lo siguiente para reiniciar la ventana acoplable:

systemctl restart docker

Es una mala idea omitir el cifrado TLS al exponer el puerto Docker, ya que cualquier persona que tenga acceso a la red a este puerto efectivamente tiene acceso total a la raíz en el host.

Imagen tirando con barras de progreso, escrita en Ir.

Este es un ejemplo de extracción de imágenes con la Docker Engine API Go and Docker Engine API y las mismas barras de progreso que las que se muestran cuando ejecuta la docker pull your_image_name en la CLI . A los efectos de las barras de progreso se utilizan algunos códigos ANSI .

package yourpackage

import (
    "context"
    "encoding/json"
    "fmt"
    "io"
    "strings"

    "github.com/docker/docker/api/types"
    "github.com/docker/docker/client"
)

// Struct representing events returned from image pulling
type pullEvent struct {
    ID             string `json:"id"`
    Status         string `json:"status"`
    Error          string `json:"error,omitempty"`
    Progress       string `json:"progress,omitempty"`
    ProgressDetail struct {
        Current int `json:"current"`
        Total   int `json:"total"`
    } `json:"progressDetail"`
}

// Actual image pulling function
func PullImage(dockerImageName string) bool {
    client, err := client.NewEnvClient()

    if err != nil {
        panic(err)
    }

    resp, err := client.ImagePull(context.Background(), dockerImageName, types.ImagePullOptions{})

    if err != nil {
        panic(err)
    }

    cursor := Cursor{}
    layers := make([]string, 0)
    oldIndex := len(layers)

    var event *pullEvent
    decoder := json.NewDecoder(resp)

    fmt.Printf("\n")
    cursor.hide()

    for {
        if err := decoder.Decode(&event); err != nil {
            if err == io.EOF {
                break
            }

            panic(err)
        }

        imageID := event.ID

        // Check if the line is one of the final two ones
        if strings.HasPrefix(event.Status, "Digest:") || strings.HasPrefix(event.Status, "Status:") {
            fmt.Printf("%s\n", event.Status)
            continue
        }

        // Check if ID has already passed once
        index := 0
        for i, v := range layers {
            if v == imageID {
                index = i + 1
                break
            }
        }

        // Move the cursor
        if index > 0 {
            diff := index - oldIndex

            if diff > 1 {
                down := diff - 1
                cursor.moveDown(down)
            } else if diff < 1 {
                up := diff*(-1) + 1
                cursor.moveUp(up)
            }

            oldIndex = index
        } else {
            layers = append(layers, event.ID)
            diff := len(layers) - oldIndex

            if diff > 1 {
                cursor.moveDown(diff) // Return to the last row
            }

            oldIndex = len(layers)
        }

        cursor.clearLine()

        if event.Status == "Pull complete" {
            fmt.Printf("%s: %s\n", event.ID, event.Status)
        } else {
            fmt.Printf("%s: %s %s\n", event.ID, event.Status, event.Progress)
        }

    }

    cursor.show()

    if strings.Contains(event.Status, fmt.Sprintf("Downloaded newer image for %s", dockerImageName)) {
        return true
    }

    return false
}

Para una mejor legibilidad, las acciones del cursor con los códigos ANSI se mueven a una estructura separada, que se ve así:

package yourpackage

import "fmt"

// Cursor structure that implements some methods
// for manipulating command line's cursor
type Cursor struct{}

func (cursor *Cursor) hide() {
    fmt.Printf("\033[?25l")
}

func (cursor *Cursor) show() {
    fmt.Printf("\033[?25h")
}

func (cursor *Cursor) moveUp(rows int) {
    fmt.Printf("\033[%dF", rows)
}

func (cursor *Cursor) moveDown(rows int) {
    fmt.Printf("\033[%dE", rows)
}

func (cursor *Cursor) clearLine() {
    fmt.Printf("\033[2K")
}

Después de eso, en su paquete principal puede llamar a la función PullImage pasando el nombre de la imagen que desea extraer. Por supuesto, antes de llamarlo, debe iniciar sesión en el registro de Docker, donde se encuentra la imagen.

Haciendo una solicitud cURL con pasar alguna estructura compleja

Al usar cURL para algunas consultas a la Docker API , puede ser un poco difícil pasar algunas estructuras complejas. Digamos que obtener una lista de imágenes permite utilizar filtros como un parámetro de consulta, que debe ser una representación JSON de la map[string][]string (sobre los mapas en Go , puede encontrar más información aquí ).
Aquí es cómo lograr esto:

curl --unix-socket /var/run/docker.sock \
    -XGET "http:/v1.29/images/json" \
    -G \
    --data-urlencode 'filters={"reference":{"yourpreciousregistry.com/path/to/image": true}, "dangling":{"true": true}}'

Aquí, el indicador -G se usa para especificar que los datos en el parámetro --data-urlencode se usarán en una solicitud HTTP GET lugar de la solicitud POST que de lo contrario se usaría. Los datos se adjuntarán a la URL con un ? separador.