Docker
API Docker Engine

Introduction

Activer l'accès à distance à l'API Docker sous Linux

Modifiez /etc/init/docker.conf et mettez à jour la variable DOCKER_OPTS comme suit:

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

Redémarrer Docker Deamon

service docker restart

Vérifier si l'API distante fonctionne

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

Activer l'accès à distance à l'API Docker sur Linux exécutant systemd

Linux fonctionnant avec systemd, comme Ubuntu 16.04, l'ajout de -H tcp://0.0.0.0:2375 à /etc/default/docker n'a pas l'effet -H tcp://0.0.0.0:2375 .

À la place, créez un fichier appelé /etc/systemd/system/docker-tcp.socket pour rendre docker disponible sur un socket TCP sur le port 4243:

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

Activez ensuite le nouveau socket:

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

Maintenant, vérifiez si l'API distante fonctionne:

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

Activer l'accès à distance avec TLS sur Systemd

Copiez le fichier d'unité du programme d'installation du package vers / etc où les modifications ne seront pas écrasées lors d'une mise à niveau:

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

Mettez à jour /etc/systemd/system/docker.service avec vos options sur 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

Notez que dockerd est le nom du démon 1.12, avant c'était le docker daemon . Notez également que 2376 est le port TLS standard de dockers, 2375 est le port non crypté standard. Reportez - vous à cette page pour connaître les étapes à suivre pour créer votre propre autorité de certification, certificat et clé d'authentification TLS.

Après avoir modifié les fichiers d'unité systemd, exécutez les opérations suivantes pour recharger la configuration systemd:

systemctl daemon-reload

Et puis exécutez ce qui suit pour redémarrer docker:

systemctl restart docker

Il est déconseillé d'ignorer le chiffrement TLS lors de l'exposition du port Docker, car toute personne disposant d'un accès réseau à ce port dispose d'un accès root complet sur l'hôte.

Tirer l'image avec des barres de progression, écrit en Go

Voici un exemple de tirage d'images à l'aide de l' Docker Engine API Go et Docker Engine API et des mêmes barres de progression que celles affichées lorsque vous exécutez docker pull your_image_name dans la CLI . Aux fins des barres de progression, certains codes ANSI sont utilisés.

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
}

Pour une meilleure lisibilité, les actions du curseur avec les codes ANSI sont déplacées vers une structure distincte, qui ressemble à ceci:

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

Après cela, dans votre paquet principal, vous pouvez appeler la fonction PullImage passant le nom de l'image que vous souhaitez extraire. Bien sûr, avant de l'appeler, vous devez être connecté au registre Docker, où se trouve l'image.

Faire une requête cURL en passant une structure complexe

Lors de l'utilisation de cURL pour certaines requêtes sur l' Docker API , il peut être difficile de faire passer certaines structures complexes. Disons que l' obtention d'une liste d'images permet d'utiliser des filtres comme paramètre de requête, qui doit être une représentation JSON de la map[string][]string (à propos des cartes dans Go vous pouvez en trouver plus ici ).
Voici comment y parvenir:

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

Ici, l' -G est utilisée pour spécifier que les données du paramètre --data-urlencode seront utilisées dans une HTTP GET au lieu de la requête POST qui serait utilisée autrement. Les données seront ajoutées à l'URL avec un ? séparateur.