Docker
डॉकर इंजन एपीआई

परिचय

लिनक्स पर डॉकर एपीआई के लिए रिमोट एक्सेस सक्षम करें

संपादित /etc/init/docker.conf और अद्यतन DOCKER_OPTS निम्नलिखित चर:

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

डॉकटर को फिर से शुरू करें

service docker restart

यदि दूरस्थ API काम कर रहा है, तो सत्यापित करें

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

लिनक्स चलाने वाले सिस्टम पर डॉकर एपीआई के लिए रिमोट एक्सेस सक्षम करें

-H tcp://0.0.0.0:2375 , जैसे कि उबंटू 16.04, -H tcp://0.0.0.0:2375 से /etc/default/docker -H tcp://0.0.0.0:2375 का वह प्रभाव नहीं है जो इसका उपयोग करता था।

इसके बजाय, पोर्ट 4243 पर टीसीपी सॉकेट पर डॉकटर उपलब्ध कराने के लिए /etc/systemd/system/docker-tcp.socket नामक फाइल बनाएं:

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

फिर नया सॉकेट सक्षम करें:

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

अब, सत्यापित करें कि दूरस्थ एपीआई काम कर रहा है:

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

Systemd पर TLS के साथ रिमोट एक्सेस सक्षम करें

पैकेज इंस्टॉलर यूनिट फ़ाइल को / etc पर कॉपी करें जहाँ अपग्रेड पर परिवर्तन नहीं लिखा जाएगा:

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

ExecStart पर अपने विकल्पों के साथ /etc/systemd/system/docker.service अपडेट करें:

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

ध्यान दें कि dockerd 1.12 डेमॉन नाम है, पहले यह था docker daemon । यह भी ध्यान दें कि 2376 डॉकर्स मानक टीएलएस पोर्ट है, 2375 मानक अनएन्क्रिप्टेड पोर्ट है। अपने स्वयं के टीएलएस स्वयं हस्ताक्षरित सीए, प्रमाण पत्र और कुंजी बनाने के लिए चरणों के लिए यह पृष्ठ देखें।

Systemd इकाई फ़ाइलों में परिवर्तन करने के बाद, systemd config पुनः लोड करने के लिए निम्नलिखित को चलाएँ:

systemctl daemon-reload

और फिर do पुनः आरंभ करने के लिए निम्नलिखित चलाएँ:

systemctl restart docker

डॉकर पोर्ट को उजागर करते समय टीएलएस एन्क्रिप्शन को छोड़ना एक बुरा विचार है क्योंकि इस पोर्ट पर नेटवर्क एक्सेस वाले कोई भी प्रभावी रूप से होस्ट पर पूर्ण रूट एक्सेस है।

गो में लिखी गई प्रगति पट्टियों के साथ चित्र खींचना

यहाँ Go और Docker Engine API का उपयोग करके छवि को खींचने का एक उदाहरण है और जब आप docker pull your_image_name चलाते हैं तो CLI में docker pull your_image_name समय दिखाए गए समान प्रगति पट्टियाँ। प्रगति सलाखों के प्रयोजनों के लिए कुछ एएनएसआई कोड का उपयोग किया जाता है।

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
}

बेहतर पठनीयता के लिए, ANSI कोड के साथ कर्सर क्रियाओं को एक अलग संरचना में ले जाया जाता है, जो इस तरह दिखता है:

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

उसके बाद अपने मुख्य पैकेज में आप PullImage फ़ंक्शन को उस छवि का नाम दे सकते हैं जिसे आप खींचना चाहते हैं। बेशक, इसे कॉल करने से पहले, आपको डॉकर रजिस्ट्री में लॉग इन करना होगा, जहां छवि है।

कुछ जटिल संरचना को पारित करने के साथ एक CURL अनुरोध करना

Docker API लिए कुछ प्रश्नों के लिए cURL का उपयोग करते समय, कुछ जटिल संरचनाओं को पारित करने के लिए यह थोड़ा मुश्किल हो सकता है। मान लीजिए, छवियों की एक सूची प्राप्त करने से एक क्वेरी पैरामीटर के रूप में फिल्टर का उपयोग करने की अनुमति मिलती है, जो कि map[string][]string का JSON प्रतिनिधित्व होना चाहिए ( Go में नक्शे के बारे में आप यहां और अधिक जानकारी प्राप्त कर सकते हैं)।
इसे कैसे प्राप्त किया जाए:

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

यहाँ -G ध्वज का उपयोग यह निर्दिष्ट करने के लिए किया जाता है कि डेटा --data-urlencode पैरामीटर का उपयोग HTTP GET अनुरोध में POST अनुरोध के बजाय किया जाएगा जो अन्यथा उपयोग किया जाएगा। डेटा URL के साथ संलग्न किया जाएगा ? विभाजक।