डोकर में आश्रित बाल चित्रों की सूची कैसे प्राप्त करें?

123

मैं एक छवि को हटाने की कोशिश कर रहा हूं और मुझे यह मिल रहा है:

# docker rmi f50f9524513f  
Failed to remove image (f50f9524513f): Error response from daemon: conflict: unable to delete f50f9524513f (cannot be forced) - image has dependent child images

यह docker संस्करण है:

# docker version
Client:
 Version:      1.10.3
 API version:  1.22
 Go version:   go1.5.3
 Git commit:   20f81dd
 Built:        Thu Mar 10 21:49:11 2016
 OS/Arch:      linux/amd64

Server:
 Version:      1.10.3
 API version:  1.22
 Go version:   go1.5.3
 Git commit:   20f81dd
 Built:        Thu Mar 10 21:49:11 2016
 OS/Arch:      linux/amd64

लेकिन कोई अतिरिक्त जानकारी नहीं है: 

# docker images --format="raw" | grep f50f9524513f -C3

repository: debian
tag: 8
image_id: f50f9524513f
created_at: 2016-03-01 18:51:14 +0000 UTC
virtual_size: 125.1 MB

repository: debian
tag: jessie
image_id: f50f9524513f
created_at: 2016-03-01 18:51:14 +0000 UTC
virtual_size: 125.1 MB

मैं आश्रित बच्चे की छवियों को कैसे प्राप्त कर सकता हूं जो इसका दावा करता है?

उस छवि आईडी के साथ न तो चल रहे हैं और न ही बंद कंटेनर हैं।

linux  docker  containers 
— nicocesar
स्रोत
9
मुझे आश्चर्य है कि डॉकटर टीम ऐसा करने के लिए एक देशी तरीका प्रदान नहीं कर सकती है?
— Amalgovinus

जवाबों:

54

संक्षिप्त उत्तर: यहां एक पायथन 3 स्क्रिप्ट है जो आश्रित डॉकटर छवियों को सूचीबद्ध करती है।

लंबा उत्तर: आप निम्न के साथ प्रश्न में छवि के बाद बनाई गई सभी छवि के लिए छवि आईडी और मूल आईडी देख सकते हैं:

docker inspect --format='{{.Id}} {{.Parent}}' \
    $(docker images --filter since=f50f9524513f --quiet)

आपको f50f9524513f के साथ शुरू होने वाली पेरेंट आईडी वाली छवियों को देखने में सक्षम होना चाहिए, फिर उन लोगों की बाल छवियों की तलाश करें , आदि .. लेकिन .Parent ऐसा नहीं है जो आप सोचते हैं। , इसलिए ज्यादातर मामलों में आपको docker images --allउस काम को करने के लिए ऊपर निर्दिष्ट करने की आवश्यकता होगी , फिर आपको सभी मध्यवर्ती परतों के लिए छवि आईडी भी मिलेंगे।

Docker आउटपुट को पार्स करने के लिए और छवियों की सूची तैयार करने के लिए खोज करने के लिए एक अधिक सीमित python3 स्क्रिप्ट यहां दी गई है:

#!/usr/bin/python3
import sys

def desc(image_ids, links):
    if links:
        link, *tail = links
        if len(link) > 1:
            image_id, parent_id = link
            checkid = lambda i: parent_id.startswith(i)
            if any(map(checkid, image_ids)):
                return desc(image_ids | {image_id}, tail)
        return desc(image_ids, tail)
    return image_ids


def gen_links(lines):
    parseid = lambda s: s.replace('sha256:', '')
    for line in reversed(list(lines)):
        yield list(map(parseid, line.split()))


if __name__ == '__main__':
    image_ids = {sys.argv[1]}
    links = gen_links(sys.stdin.readlines())
    trunc = lambda s: s[:12]
    print('\n'.join(map(trunc, desc(image_ids, links))))

यदि आप इसे बचाते हैं, तो आप desc.pyइसे निम्नानुसार लागू कर सकते हैं:

docker images \
    | fgrep -f <(docker inspect --format='{{.Id}} {{.Parent}}' \
        $(docker images --all --quiet) \
        | python3 desc.py f50f9524513f )

या बस ऊपर दिए गए गस्ट का उपयोग करें , जो एक ही काम करता है।

— आर्येह लीब तौआरोग
स्रोत
2
क्या होगा अगर उनमें से कोई भी उम्मीद पात्रों से शुरू न हो? क्या यह एक संभावित बग इंगित करता है? मैं मैक बीटा के लिए डॉकर पर हूं, एफडब्ल्यूआईडब्ल्यू, ताकि मुझे आश्चर्य न हो।
— neverfox
या तो यह एक बग है, या इसका मतलब है कि प्रश्न में छवि किसी भी बच्चे की नहीं है।
— आर्येह लीब तौआरोग
2
यह वास्तव में मूल प्रश्न का उत्तर नहीं देता है। इससे पता चलता है कि प्रश्न में छवि के बाद क्या बनाया गया था, जो उस चित्र पर निर्भर हो सकता है या नहीं हो सकता है जिसे पोस्टर हटाने की कोशिश कर रहा था। साइमन ब्रैडी का जवाब कम से कम छवियों के छोटे आकार के लिए चाल करता है।
— पेंगुइन
2
@ पेंग्विनकोडर है कि अजगर लिपि क्या है।
— आर्येह लीब तौआरोग
@Neverfox की तरह, यह जवाब मेरे काम नहीं आया। हालांकि साइमन ब्रैडी के जवाब ने काम किया, हालांकि।
— मार्क
91

यदि आपके पास बहुत अधिक संख्या में चित्र नहीं हैं, तो हमेशा जानवर-बल दृष्टिकोण होता है:

for i in $(docker images -q)
do
    docker history $i | grep -q f50f9524513f && echo $i
done | sort -u
— साइमन ब्रैडी
स्रोत
1
मुझे लगता है कि यह "सबसे अच्छा" समाधान है। आप इसे थोड़ा विस्तार कर सकते हैं और इसे थोड़ा और स्पष्ट echo $1कर सकते हैं कि बदसूरत (लेकिन अभी भी क्रूरतापूर्ण) को बदलने से क्या होता है ( छवि आईडी के लिए झंडे docker images | grep $iका उपयोग करने की तुलना में डॉक संस्करणों में अधिक पोर्टेबल --filter)
— जॉन वी।
15

डॉकविज़ स्थापित करें और पेड़ के दृश्य में छवि आईडी से शाखाओं का पालन करें:

go get github.com/justone/dockviz
$(go env GOPATH)/bin/dockviz images --tree -l
— mmoya
स्रोत
sudo apt-get update ; sudo apt-get install golang-go; export GOPATH=$HOME/.goपहले करना बेहतर है ।
— लॉरिटोपार्सी
3
MacOS पर उपलब्ध हैbrew install dockviz
— rcoup
उबटन का उपयोग करते समय सावधानी बरतें। यह आमतौर पर जाने के लिए पुराने भंडार का उपयोग कर रहा है
— Qohelet
7

मैंने शेल स्क्रिप्ट के साथ एक डस्ट बनाया है जो डॉक इमेज के वंशज पेड़ को प्रिंट करने के लिए है, किसी को भी बैश समाधान में दिलचस्पी लेनी चाहिए:

#!/bin/bash
parent_short_id=$1
parent_id=`docker inspect --format '{{.Id}}' $1`

get_kids() {
    local parent_id=$1
    docker inspect --format='ID {{.Id}} PAR {{.Parent}}' $(docker images -a -q) | grep "PAR ${parent_id}" | sed -E "s/ID ([^ ]*) PAR ([^ ]*)/\1/g"
}

print_kids() {
    local parent_id=$1
    local prefix=$2
    local tags=`docker inspect --format='{{.RepoTags}}' ${parent_id}`
    echo "${prefix}${parent_id} ${tags}"

    local children=`get_kids "${parent_id}"`

    for c in $children;
    do
        print_kids "$c" "$prefix  "
    done
}

print_kids "$parent_id" ""
— मिशाल लिन्हार्ड
स्रोत
हालांकि यह लिंक प्रश्न का उत्तर दे सकता है, लेकिन उत्तर के आवश्यक भागों को शामिल करना और संदर्भ के लिए लिंक प्रदान करना बेहतर है। लिंक-केवल उत्तर अमान्य हो सकते हैं यदि लिंक किए गए पृष्ठ बदल जाते हैं। - समीक्षा से
— जुआन
मुझे कोड को फ़ॉर्मेट करने में परेशानी हुई, इसलिए मैंने इसे छोड़ दिया, इस जन को करने के लिए धन्यवाद
— मिशाल लिनहार्ड
2

मैंने अपनी अंतिम "छवि" (परत, वास्तव में - जो मुझे फेंक दिया है, जैसा कि मैं सिर्फ डॉक बिल्डरों में ले रहा हूं) को संरक्षित करने के लिए मैंने ऐसा किया।

मुझे पूरा मिल रहा था "... मजबूर नहीं किया जा सकता ..." संदेश। मुझे एहसास हुआ कि मैं उन छवियों को नहीं हटा सकता जिनकी मुझे आवश्यकता नहीं थी क्योंकि वे वास्तव में 'docker प्रतिबद्ध' द्वारा बनाई गई स्वतंत्र छवियां नहीं हैं। मेरा मुद्दा था, मेरे पास बेस इमेज और मेरे फाइनल के बीच में कई चित्र (या परतें) थे, और बस साफ करने की कोशिश कर रहा था कि मुझे बच्चे और माता-पिता के बारे में त्रुटि / चेतावनी कहां मिले।

  1. मैंने एक तारकोल को अंतिम छवि (या परत, यदि आप होगा) को निर्यात किया।
  2. फिर मैंने अपने अंतिम सहित सभी छवियों को हटा दिया - मैंने इसे एक टारबॉल में सहेजा है, जबकि मुझे यकीन नहीं था कि अगर मैं इसका उपयोग कर पाऊंगा, तो मैं केवल प्रयोग कर रहा था।
  3. मैं फिर भागा docker image load -i FinalImage.tar.gz। आउटपुट कुछ इस तरह था:
7d9b54235881: Loading layer [==================================================>]  167.1MB/167.1MB
c044b7095786: Loading layer [==================================================>]  20.89MB/20.89MB
fe94dbd0255e: Loading layer [==================================================>]  42.05MB/42.05MB
19abaa1dc0d4: Loading layer [==================================================>]  37.96MB/37.96MB
4865d7b6fdb2: Loading layer [==================================================>]  169.6MB/169.6MB
a0c115c7b87c: Loading layer [==================================================>]    132MB/132MB

भरी हुई छवि आईडी: sha256: 82d4f8ef9ea1eab72d989455728762ed3c0fe35fd85acf9edc47b41dacfd6382

अब, जब मैं 'docker image ls' के साथ सूची देता हूं, तो मेरे पास केवल मूल आधार छवि होती है, और अंतिम छवि जिसे मैंने पहले टारबॉल में सहेजा था।

[root@docker1 ~]# docker image ls
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
httpd               import              82d4f8ef9ea1        3 days ago          747MB
centos              httpd               36540f359ca3        5 weeks ago         193MB

मेरा सिस्टम अब 'साफ' है। मेरे पास केवल वे चित्र हैं जो मुझे चाहिए। मैंने एक समस्या के बिना आधार छवि को भी हटा दिया।

[root@docker1 ~]# docker rmi 36540f359ca3
Untagged: centos:httpd
Untagged:     centos@sha256:c1010e2fe2b635822d99a096b1f4184becf5d1c98707cbccae00be663a9b9131
Deleted: sha256:36540f359ca3b021d4b6a37815e9177b6c2bb3817598979ea55aee7ecc5c2c1f
— जेरोम जॉर्डन
स्रोत
अच्छा जवाब है, लेकिन लोड केवल "डोकर सेव" से बनाई गई छवि पर उपयोग किया जाना चाहिए। एक "docker निर्यात" के लिए उचित पुनर्स्थापना "
— docker
2

यदि आप इस शैल फ़ंक्शन का उपयोग कर सकते हैं, तो स्लश और माइकल हॉफमैन के जवाबों के आधार पर , आपके पास एक टन चित्र नहीं है:

docker_image_desc() {
  for image in $(docker images --quiet --filter "since=${1}"); do
    if [ $(docker history --quiet ${image} | grep ${1}) ]; then
      docker_image_desc "${image}"
    fi
  done
  echo "${1}"
}

और फिर इसका उपयोग करके कॉल करें

docker_image_desc <image-id> | awk '!x[$0]++'
— मैक्सिम सुसलोव
स्रोत
2

यहाँ Python API ( pip install docker) पर आधारित एक समाधान है जो पुनरावर्ती वंशों को उनके टैग (यदि हो तो) के साथ लिस्ट करता है, रिश्ते की गहराई (बच्चों, नाती-पोतों, आदि) के अनुसार इंडेंटेशन बढ़ाता है:

import argparse
import docker

def find_img(img_idx, id):
    try:
        return img_idx[id]
    except KeyError:
        for k, v in img_idx.items():
            if k.rsplit(":", 1)[-1].startswith(id):
                return v
    raise RuntimeError("No image with ID: %s" % id)

def get_children(img_idx):
    rval = {}
    for img in img_idx.values():
        p_id = img.attrs["Parent"]
        rval.setdefault(p_id, set()).add(img.id)
    return rval

def print_descendants(img_idx, children_map, img_id, indent=0):
    children_ids = children_map.get(img_id, [])
    for id in children_ids:
        child = img_idx[id]
        print(" " * indent, id, child.tags)
        print_descendants(img_idx, children_map, id, indent=indent+2)

def main(args):
    client = docker.from_env()
    img_idx = {_.id: _ for _ in client.images.list(all=True)}
    img = find_img(img_idx, args.id)
    children_map = get_children(img_idx)
    print_descendants(img_idx, children_map, img.id)

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("id", metavar="IMAGE_ID")
    main(parser.parse_args())

उदाहरण:

$ python find_dep_img.py 549afbf12931
 sha256:913d0981fdc7d2d673f2c8135b7afd32ba5037755e89b00432d3460422ba99b9 []
   sha256:0748dbc043b96ef9f88265c422e0267807f542e364b7a7fadf371ba5ee082b5d []
     sha256:6669414d2a0cc31b241a1fbb00c0ca00fa4dc4fa65dffb532bac90d3943d6a0a []
       sha256:a6441e7d9e92511608aad631f9abe8627033de41305c2edf7e03ee36f94f0817 ['foo/bar:latest']

मैंने इसे https://gist.github.com/simleo/10ad923f9d8a2fa410f7ec2d7e96ad57 पर उपलब्ध कराया है

— simleo
स्रोत
1

यहां उन बाल चित्रों की सूची प्राप्त करने का एक सरल तरीका है जो एक मूल छवि पर निर्भर हैं:

image_id=123456789012

docker images -a -q --filter since=$image_id |
xargs docker inspect --format='{{.Id}} {{.Parent}}' |
grep $image_id

उदाहरण के लिए बच्चे / माता-पिता के चित्र आईडी की एक सूची उत्पन्न होगी (संक्षिप्तता के लिए संक्षिप्त):

sha256:abcdefghijkl sha256:123456789012

लेफ्ट साइड चाइल्ड इमेज आईडी है, राइट साइड पैरेंट इमेज आईडी है जिसे हम डिलीट करने की कोशिश कर रहे हैं, लेकिन यह कह रहा है "इमेज में डिपेंडेड चाइल्ड इमेजेज हैं"। यह हमें बताता है कि abcdefghijklवह बच्चा है जिस पर निर्भर है 123456789012। तो हम पहले की जरूरत है docker rmi abcdefghijkl, तो आप कर सकते हैं docker rmi 123456789012।

अब, आश्रित बाल छवियों की एक श्रृंखला हो सकती है, इसलिए आपको अंतिम बच्चे को खोजने के लिए दोहराते रहना पड़ सकता है।

— wisbucky
स्रोत
0

आप Docker के नीचे निर्देशिका के माध्यम से माता-पिता और बच्चे के संबंध के बावजूद Docker छवियों को हटा सकते हैं 

/var/lib/docker/image/devicemapper/imagedb/content/sha256

इस निर्देशिका में आप डॉकर चित्र पा सकते हैं, जिससे आप जो चाहें हटा सकते हैं।

— JVN
स्रोत
मैं docker API का उपयोग करके पोर्टेबल कमांड बनाने की कोशिश कर रहा हूं, डिवाइस मैपर और docker इंजन (उदाहरण के लिए docker swarm के विपरीत) यह एक गैर पोर्टेबल समाधान बनाता है। फाइलसिस्टम में फ़ाइलों को हटाने का जोखिम भरा है, जबकि अन्य प्रक्रिया (docker डेमन सहित) इसका उपयोग कर सकती है।
— निकोस्कर
यह मैकोस पर कहां है?
— एंथनी कोंग
1
* चेतावनी "यह भविष्य में कंटेनर को हटाने और खींचने के साथ कई त्रुटियां पैदा कर सकता है। कभी भी /var/lib/dockerसीधे हाथ से
— डायर को
0

कैसा रहेगा:

ID=$(docker inspect --format="{{.Id}}" "$1")
IMAGES=$(docker inspect --format="{{if eq \"$ID\" .Config.Image}}{{.Id}}{{end}}" $(docker images --filter since="$ID" -q))
echo $(printf "%s\n" "${IMAGES[@]}" | sort -u)

यह sha256:उपसर्ग के साथ चाइल्ड इमेज आईडी प्रिंट करेगा ।
मेरे पास निम्नलिखित भी थे, जो नामों को जोड़ते हैं:

IMAGES=$(docker inspect --format="{{if eq \"$ID\" .Config.Image}}{{.Id}}{{.RepoTags}}{{end}}" $(docker images --filter since="$ID" -q))
  • ID= छवि की पूरी आईडी हो जाती है
  • IMAGES= उन सभी बाल छवियों को प्राप्त करता है जिनके पास यह छवि है जो एक के रूप में सूचीबद्ध है Image
  • echo... परिणामों को डुप्लिकेट और ईकोस निकालता है
— जस्टिन
स्रोत
मुझे गो प्रारूप स्थितियां पसंद हैं, लेकिन शायद वे इस उपयोग के मामले के लिए एक फिल्टर के रूप में बेहतर हैं।
— निगलना
0

मैंने इसे बच्चों को खोजने, उनके रेपो टैग, और प्रिंट करने के लिए पकाया कि वे क्या कर रहे हैं:

docker_img_tree() {
    for i in $(docker image ls -qa) ; do
        [ -f "/tmp/dii-$i"  ] || ( docker image inspect $i > /tmp/dii-$i)
        if grep -qiE 'Parent.*'$1 /tmp/dii-$i ; then
            echo "$2============= $i (par=$1)"
            awk '/(Cmd|Repo).*\[/,/\]/' /tmp/dii-$i | sed "s/^/$2/"
            docker_img_tree $i $2===
        fi
    done
}

यदि आपका होस्ट सुरक्षित नहीं है, तो / tmp / dii- * हटाना न भूलें।

— android.weasel
स्रोत
-6

मैं भी इसी मुद्दे का सामना कर रहा था। समस्या को हल करने के लिए नीचे दिए गए चरण।

सभी चल रहे कंटेनरों को रोकें

docker stop $ (docker ps -aq) सभी कंटेनरों को हटा दें

docker rm $ (docker ps -aq) सभी चित्र निकालें

docker rmi $ (डॉक इमेज -q)

— राम पसुपुला
स्रोत
यह उत्तर प्रश्नकर्ता की आवश्यकता को पूरा नहीं करता है।
— अंकुर लोरिया
कृपया उन चीजों पर टिप्पणी करना बंद करें जिन्हें लोग संभावित रूप से कॉपी और पेस्ट कर सकते हैं और हानिकारक चीजें कर सकते हैं।
— निकोस्कर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.