Docker
Docker Engine-API

Einführung

Aktivieren Sie den Remote-Zugriff auf die Docker-API unter Linux

Bearbeiten /etc/init/docker.conf die DOCKER_OPTS /etc/init/docker.conf und aktualisieren Sie die Variable DOCKER_OPTS wie folgt:

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

Starten Sie den Docker-Deamon neu

service docker restart

Überprüfen Sie, ob die Remote-API funktioniert

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

Aktivieren Sie den Remote-Zugriff auf die Docker-API unter Linux, auf dem systemd ausgeführt wird

Linux, auf dem Systemd ausgeführt wird, wie Ubuntu 16.04, und das Hinzufügen von -H tcp://0.0.0.0:2375 zu /etc/default/docker hat nicht die -H tcp://0.0.0.0:2375 Wirkung.

Erstellen Sie stattdessen eine Datei mit dem Namen /etc/systemd/system/docker-tcp.socket , um das Docker auf einem TCP-Socket an Port 4243 verfügbar zu machen:

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

Dann aktivieren Sie den neuen Sockel:

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

Überprüfen Sie nun, ob die Remote-API funktioniert:

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

Aktivieren Sie den Remote-Zugriff mit TLS auf Systemd

Kopieren Sie die Einheitendatei des Paketinstallationsprogramms nach / etc, wo die Änderungen bei einem Upgrade nicht überschrieben werden:

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

Aktualisieren Sie /etc/systemd/system/docker.service mit Ihren Optionen in 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

Beachten Sie, dass dockerd der Name des 1.12-Daemons ist, bevor es sich um einen docker daemon . Beachten Sie auch, dass 2376 der Standard-TLS-Port von Dockers ist, 2375 der unverschlüsselte Standardport. Auf dieser Seite finden Sie Schritte zum Erstellen Ihrer eigenen TLS-Zertifizierungsstelle, des Zertifikats und des Schlüssels.

Führen Sie nach dem Ändern der systemd-Einheitendateien die folgenden Schritte aus, um die systemd-Konfiguration erneut zu laden:

systemctl daemon-reload

Führen Sie dann Folgendes aus, um das Andockfenster neu zu starten:

systemctl restart docker

Es ist keine gute Idee, die TLS-Verschlüsselung zu überspringen, wenn der Docker-Port verfügbar gemacht wird, da jeder, der über Netzwerkzugriff auf diesen Port verfügt, auf dem Host über vollständigen Root-Zugriff verfügt.

Bild ziehen mit Fortschrittsbalken, geschrieben in Go

Hier ein Beispiel für das Ziehen von docker pull your_image_name mit der Go und Docker Engine API und den gleichen Fortschrittsbalken wie beim Ausführen des docker pull your_image_name in der CLI . Für die Zwecke der Fortschrittsbalken werden einige ANSI-Codes verwendet .

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
}

Zur besseren Lesbarkeit werden Cursoraktionen mit den ANSI-Codes in eine separate Struktur verschoben, die wie folgt aussieht:

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

Danach können Sie in Ihrem PullImage die PullImage Funktion PullImage , indem Sie den PullImage übergeben, den Sie ziehen möchten. Bevor Sie es aufrufen können, müssen Sie natürlich in der Docker-Registry angemeldet sein, wo sich das Image befindet.

Eine cURL-Anfrage mit der Übergabe einer komplexen Struktur erstellen

Wenn Sie cURL für einige Abfragen an die Docker API , kann es schwierig sein, einige komplexe Strukturen zu übergeben. Nehmen wir an, eine Liste von Bildern zu erhalten, ermöglicht die Verwendung von Filtern als Abfrageparameter, die eine JSON Darstellung von map[string][]string (Informationen zu den Maps in Go Sie hier ).
So erreichen Sie das:

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

Mit dem Flag -G wird angegeben, dass die Daten im Parameter --data-urlencode in einer HTTP GET Anforderung anstelle der POST Anforderung verwendet werden, die andernfalls verwendet würde. Die Daten werden mit einem ? An die URL angehängt ? Separator.