Docker
Docker Engine API

Invoering

Schakel externe toegang tot Docker API in Linux in

Bewerk /etc/init/docker.conf en DOCKER_OPTS variabele DOCKER_OPTS als volgt bij:

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

Start Docker deamon opnieuw

service docker restart

Controleer of Remote API werkt

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

Externe toegang tot Docker API inschakelen op Linux met systemd

Linux met systemd, zoals Ubuntu 16.04, het toevoegen van -H tcp://0.0.0.0:2375 aan /etc/default/docker heeft niet het effect dat het vroeger had.

Maak in plaats daarvan een bestand met de naam /etc/systemd/system/docker-tcp.socket om docker beschikbaar te maken op een TCP-socket op poort 4243:

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

Schakel vervolgens de nieuwe socket in:

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

Controleer nu of Remote API werkt:

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

Externe toegang inschakelen met TLS op Systemd

Kopieer het bestand van het installatiepakket van het pakket naar / etc, waar wijzigingen niet worden overschreven bij een upgrade:

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

Update /etc/systemd/system/docker.service met uw opties op 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

Merk op dat dockerd de naam is van 1.12 daemon, voorheen was het docker daemon . Merk ook op dat 2376 de standaard TLS-poort van de haven is, 2375 is de standaard niet-gecodeerde poort. Zie deze pagina voor stappen om uw eigen door TLS zelf ondertekende CA, cert en sleutel te maken.

Nadat u wijzigingen in de bestanden van de systemd-eenheid hebt aangebracht, voert u de volgende stappen uit om de systemd-configuratie opnieuw te laden:

systemctl daemon-reload

En voer vervolgens het volgende uit om het koppelvenster opnieuw te starten:

systemctl restart docker

Het is een slecht idee om TLS-codering over te slaan bij het vrijgeven van de Docker-poort, omdat iedereen met netwerktoegang tot deze poort effectief volledige root-toegang op de host heeft.

Afbeelding trekken met voortgangsbalken, geschreven in Go

Hier is een voorbeeld van het trekken van afbeeldingen met behulp van Go en Docker Engine API en dezelfde voortgangsbalken die worden weergegeven wanneer u docker pull your_image_name uitvoert, docker pull your_image_name in de CLI . Voor de voortgangsbalken worden enkele ANSI-codes gebruikt .

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
}

Voor een betere leesbaarheid worden cursoracties met de ANSI-codes verplaatst naar een afzonderlijke structuur, die er als volgt uitziet:

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

Daarna kunt u in uw PullImage functie PullImage met de afbeeldingsnaam die u wilt PullImage . Natuurlijk moet u, voordat u het aanroept, zijn aangemeld bij het Docker-register, waar de afbeelding staat.

Een CURL-aanvraag doen met een complexe structuur

Wanneer u cURL voor sommige query's naar de Docker API , kan het een beetje lastig zijn om enkele complexe structuren door te geven. Laten we zeggen Let's, het krijgen van een lijst met afbeeldingen maakt gebruik van filters als een query parameter, die moeten een zijn JSON representatie van map[string][]string (ongeveer de kaarten in Go kun je meer vinden hier ).
Hier is hoe dit te bereiken:

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

Hier wordt de vlag -G gebruikt om aan te geven dat de gegevens in de parameter --data-urlencode worden gebruikt in een HTTP GET verzoek in plaats van het POST verzoek dat anders zou worden gebruikt. De gegevens worden aan de URL toegevoegd met een ? separator.