Docker
Docker Engine API

Introduktion

Aktivera fjärråtkomst till Docker API på Linux

Redigera /etc/init/docker.conf och uppdatera variabeln DOCKER_OPTS till följande:

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

Starta om Docker-deamon

service docker restart

Verifiera om Remote API fungerar

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

Aktivera fjärråtkomst till Docker API på Linux som kör systemd

Linux som kör systemd, som Ubuntu 16.04, och lägger till -H tcp://0.0.0.0:2375 till /etc/default/docker har inte den effekt som den brukade.

/etc/systemd/system/docker-tcp.socket istället en fil som heter /etc/systemd/system/docker-tcp.socket att göra dockaren tillgänglig på ett TCP-uttag på port 4243:

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

Aktivera sedan det nya uttaget:

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

Kontrollera nu om Remote API fungerar:

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

Aktivera fjärråtkomst med TLS på Systemd

Kopiera paketinstallationsenhetsfilen till / etc där förändringar inte kommer att skrivas över vid en uppgradering:

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

Uppdatera /etc/systemd/system/docker.service med dina alternativ på 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

Observera att dockerd är namnet 1.12 daemon, innan det var docker daemon . Observera också att 2376 är dockare standard TLS-port, 2375 är den standard okrypterade porten. Se den här sidan för steg för att skapa din egen TLS självsignerade CA, cert och nyckel.

När du har gjort ändringar i systemd-enhetens filer, kör följande för att ladda om systemd-konfigurationen:

systemctl daemon-reload

Och kör sedan följande för att starta om dockaren:

systemctl restart docker

Det är en dålig idé att hoppa över TLS-kryptering när du exponerar Docker-porten eftersom alla som har nätverksåtkomst till denna port effektivt har full rootåtkomst på värden.

Bilddragning med framstegsfält, skrivet i Go

Här är ett exempel på bilddragning med Go och Docker Engine API och samma framstegsfält som de som visas när du kör docker pull your_image_name i CLI . För användning av framstegsraden används vissa ANSI-koder .

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
}

För bättre läsbarhet flyttas markörhandlingar med ANSI-koderna till en separat struktur, som ser ut så här:

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

Efter det i ditt huvudpaket kan du ringa PullImage funktionen som passerar det PullImage du vill dra. Naturligtvis måste du logga in i Docker-registret, där bilden är, innan du ringer till det.

Gör en CURL-begäran med godkänd komplex struktur

När du använder cURL för vissa frågor till Docker API kan det vara lite svårt att passera vissa komplexa strukturer. Låt oss säga, att få en lista med bilder tillåter att använda filter som en frågeparameter, som måste vara en JSON representation av map[string][]string (om kartorna i Go du hitta mer här ).
Så här uppnår du detta:

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

Här används -G flaggan för att specificera att data i --data-urlencode kommer att användas i en HTTP GET begäran istället för POST begäran som annars skulle användas. Uppgifterna läggs till i URL: n med en ? separator.