Reputation: 59973

How can I find a Docker image with a specific tag in Docker registry on the Docker command line?

I try to locate one specific tag for a Docker image. How can I do it on the command line? I want to avoid downloading all the images and then removing the unneeded ones.

In the official Ubuntu release, https://registry.hub.docker.com/_/ubuntu/, there are several tags (release for it), while when I search it on the command line,

user@ubuntu:~$ docker search ubuntu | grep ^ubuntu
ubuntu              Official Ubuntu base image                          354
ubuntu-upstart      Upstart is an event-based replacement for ...   7
ubuntufan/ping                                                0
ubuntu-debootstrap                                                   0

Also in the help of command line search https://docs.docker.com/engine/reference/commandline/search/, no clue how it can work?

Is it possible in the docker search command?

If I use a raw command to search via the Docker registry API, then the information can be fetched:

   $ curl https://registry.hub.docker.com//v1/repositories/ubuntu/tags | python -mjson.tool
   [
    {
        "layer": "ef83896b",
        "name": "latest"
    },
    .....
    {
        "layer": "463ff6be",
        "name": "raring"
    },
    {
        "layer": "195eb90b",
        "name": "saucy"
    },
    {
        "layer": "ef83896b",
        "name": "trusty"
    }
]

Upvotes: 68

Answers (13)

BMitch

Reputation: 263856

Listing tags in a repository is documented in the OCI tag listing API which calls the /v2/<name>/tags/list endpoint and parses the JSON output. You can manually script this with commands like curl, but that has a few downsides, particularly authentication and pagination. Different registries implement pagination differently, potentially breaking scripts that believe they have received the full list when they've only seen the first page of results. And authentication has different implementations depending on whether the registry points you to a token server or request basic auth, and whether you have a login or attempt to anonymously access the registry.

My suggestion instead is to use any of the various tools that handle all of the complexity for you, including crane from Google, oras from Microsoft, skopeo from RedHat, and regctl from myself.

crane ls ubuntu

oras repo tags docker.io/library/ubuntu

skopeo list-tags docker://docker.io/library/ubuntu

regctl tag ls ubuntu

Upvotes: 0

Dean Grant

Reputation: 1

I came across this question while solving a similar problem involving Docker image tags.

In my case, I was working with an image that had multiple tags, some of which were hidden behind pagination in the Docker Hub API. By writing a script that paginated through the tags and filtered based on a specific naming pattern, I was able to solve the problem.

This code snippet is part of a wider pipeline script used to automate the process of identifying and pulling the latest Docker image for deployment

Steps:

Initialize Pagination: Begin fetching tags from the Docker Hub API with pagination to handle repositories with a large number of tags.
Loop through all pages: Paginate through the results until no more pages are left.
Filter the Tags: Use grep to filter tags that match the specified pattern (in this case, something like 20.x-alpine).
Find the Latest Tag: Use sort and tail to get the latest version of the tag from the list.

# Retrieve the latest tag for the image from the Docker Hub registry by
# paginating through the results and filtering the tags that match the
# specified pattern.

# Initialize the page number to start pagination.
PAGE=1
# Initialize an empty string to store the tags.
TAGS=""

# Start an infinite loop to handle pagination and fetch all the pages of the
# results.
while true; do
  # Send a GET request to the Docker Hub API to retrieve the tags for the
  # image, limiting the results to 100 tags per page.
  RESPONSE=$(curl -s "https://registry.hub.docker.com/v2/repositories/library/${IMAGE_NAME}/tags?page_size=100&page=$PAGE")

  # Extract tags from the current page that match the specified pattern.
  # Node.js 20, the latest tag must be 20.x.
  PAGE_TAGS=$(echo "$RESPONSE" | jq -r '.results[].name' | grep -E "^20(\.[0-9]+)*-alpine[0-9.]*$" || true)

  # Append the discovered tags to the list of tags.
  TAGS="${TAGS}${PAGE_TAGS}"$'\n'

  # Evaluate if there are more pages of results. If there are no more pages,
  # then break the loop.
  NEXT_PAGE=$(echo "$RESPONSE" | jq -r '.next')
  if [ "$NEXT_PAGE" == "null" ]; then
    break
  fi

  # If there are more pages, increment the page counter to fetch the next page.
  PAGE=$((PAGE + 1))
done

# Return the latest tag from the list of tags.
LATEST_TAG=$(echo "$TAGS" | sort -V | tail -n 1)

Upvotes: 0

Joe Linoff

Reputation: 771

This script (docker-show-repo-tags.sh) should work for any Docker enabled host that has curl, sed, grep, and sort. This was updated to reflect the fact the repository tag URLs changed.

This version correctly parses the "name": field without a JSON parser.

#!/bin/sh
# 2022-07-20
# Simple script that will display Docker repository tags
# using basic tools: curl, awk, sed, grep, and sort.
# Usage:
#   $ docker-show-repo-tags.sh ubuntu centos
#   $ docker-show-repo-tags.sh centos | cat -n
for Repo in "$@" ; do
    URL="https://registry.hub.docker.com/v2/repositories/library/$Repo/tags/"
    curl -sS "$URL" | \
        /usr/bin/sed -Ee 's/("name":)"([^"]*)"/\n\1\2\n/g' | \
        grep '"name":' | \
        awk -F: '{printf("'$Repo':%s\n",$2)}'
done

This older version no longer works. Many thanks to @d9k for pointing this out!

#!/bin/sh
# WARNING: This no long works!
# Simple script that will display Docker repository tags
# using basic tools: curl, sed, grep, and sort.
#
# Usage:
#   $ docker-show-repo-tags.sh ubuntu centos
for Repo in $* ; do
    curl -sS "https://hub.docker.com/r/library/$Repo/tags/" | \
        sed -e $'s/"tags":/\\\n"tags":/g' -e $'s/\]/\\\n\]/g' | \
        grep '^"tags"' | \
        grep '"library"' | \
        sed -e $'s/,/,\\\n/g' -e 's/,//g' -e 's/"//g' | \
        grep -v 'library:' | \
        sort -fu | \
        sed -e "s/^/${Repo}:/"
done

This older version no longer works. Many thanks to @viky for pointing this out!

#!/bin/sh
# WARNING: This no long works!
# Simple script that will display Docker repository tags.
#
# Usage:
#   $ docker-show-repo-tags.sh ubuntu centos
for Repo in $* ; do
  curl -s -S "https://registry.hub.docker.com/v2/repositories/library/$Repo/tags/" | \
    sed -e $'s/,/,\\\n/g' -e $'s/\[/\\\[\n/g' | \
    grep '"name"' | \
    awk -F\" '{print $4;}' | \
    sort -fu | \
    sed -e "s/^/${Repo}:/"
done

This is the output for a simple example:

$ docker-show-repo-tags.sh centos | cat -n
     1    centos:5
     2    centos:5.11
     3    centos:6
     4    centos:6.10
     5    centos:6.6
     6    centos:6.7
     7    centos:6.8
     8    centos:6.9
     9    centos:7.0.1406
    10    centos:7.1.1503
    11    centos:7.2.1511
    12    centos:7.3.1611
    13    centos:7.4.1708
    14    centos:7.5.1804
    15    centos:centos5
    16    centos:centos5.11
    17    centos:centos6
    18    centos:centos6.10
    19    centos:centos6.6
    20    centos:centos6.7
    21    centos:centos6.8
    22    centos:centos6.9
    23    centos:centos7
    24    centos:centos7.0.1406
    25    centos:centos7.1.1503
    26    centos:centos7.2.1511
    27    centos:centos7.3.1611
    28    centos:centos7.4.1708
    29    centos:centos7.5.1804
    30    centos:latest

Upvotes: 10

Nev Stokes

Reputation: 9789

For anyone stumbling across this in modern times, you can use Skopeo to retrieve an image's tags from the Docker registry:

$ skopeo list-tags docker://jenkins/jenkins \
| jq -r '.Tags[] | select(. | contains("lts-alpine"))' \
| sort --version-sort --reverse

lts-alpine
2.277.3-lts-alpine
2.277.2-lts-alpine
2.277.1-lts-alpine
2.263.4-lts-alpine
2.263.3-lts-alpine
2.263.2-lts-alpine
2.263.1-lts-alpine
2.249.3-lts-alpine
2.249.2-lts-alpine
2.249.1-lts-alpine
2.235.5-lts-alpine
2.235.4-lts-alpine
2.235.3-lts-alpine
2.235.2-lts-alpine
2.235.1-lts-alpine
2.222.4-lts-alpine

Upvotes: 3

Denilson Sá Maia

Reputation: 49387

The v2 API seems to use some kind of pagination, so that it does not return all the available tags. This is clearly visible in projects such as python (or library/python). Even after quickly reading the documentation, I could not manage to work with the API correctly (maybe it is the wrong documentation).

Then I rewrote the script using the v1 API, and it is still using jq:

#!/bin/bash

repo="$1"

if [[ "${repo}" != */* ]]; then
    repo="library/${repo}"
fi

url="https://registry.hub.docker.com/v1/repositories/${repo}/tags"
curl -s -S "${url}" | jq '.[]["name"]' | sed 's/^"\(.*\)"$/\1/' | sort

The full script is available at: https://github.com/denilsonsa/small_scripts/blob/master/docker_remote_tags.sh

I've also written an improved version (in Python) that aggregates tags that point to the same version: https://github.com/denilsonsa/small_scripts/blob/master/docker_remote_tags.py

Upvotes: 3

hpgmiskin

Reputation: 538

You can use Visual Studio Code to provide autocomplete for available Docker images and tags. However, this requires that you type the first letter of a tag in order to see autocomplete suggestions.

For example, when writing FROM ubuntu it offers autocomplete suggestions like ubuntu, ubuntu-debootstrap and ubuntu-upstart. When writing FROM ubuntu:a it offers autocomplete suggestions, like ubuntu:artful and ubuntu:artful-20170511.1

Upvotes: 0

Helder Dias

Reputation: 21

Add this function to your .zshrc file or run the command manually:

#usage list-dh-tags <repo>
#example: list-dh-tags node
function list-dh-tags(){
    wget -q https://registry.hub.docker.com/v1/repositories/$1/tags -O -  | sed -e 's/[][]//g' -e 's/"//g' -e 's/ //g' | tr '}' '\n'  | awk -F: '{print $3}'
}

Thanks to this -> How can I list all tags for a Docker image on a remote registry?

Upvotes: 2

Javier Buzzi

Reputation: 6818

I didn't like any of the solutions above because A) they required external libraries that I didn't have and didn't want to install. B) I didn't get all the pages.

The Docker API limits you to 100 items per request. This will loop over each "next" item and get them all (for Python it's seven pages; other may be more or less... It depends)

If you really want to spam yourself, remove | cut -d '-' -f 1 from the last line, and you will see absolutely everything.

url=https://registry.hub.docker.com/v2/repositories/library/redis/tags/?page_size=100 `# Initial url` ; \
( \
  while [ ! -z $url ]; do `# Keep looping until the variable url is empty` \
    >&2 echo -n "." `# Every iteration of the loop prints out a single dot to show progress as it got through all the pages (this is inline dot)` ; \
    content=$(curl -s $url | python -c 'import sys, json; data = json.load(sys.stdin); print(data.get("next", "") or ""); print("\n".join([x["name"] for x in data["results"]]))') `# Curl the URL and pipe the output to Python. Python will parse the JSON and print the very first line as the next URL (it will leave it blank if there are no more pages) then continue to loop over the results extracting only the name; all will be stored in a variable called content` ; \
    url=$(echo "$content" | head -n 1) `# Let's get the first line of content which contains the next URL for the loop to continue` ; \
    echo "$content" | tail -n +2 `# Print the content without the first line (yes +2 is counter intuitive)` ; \
  done; \
  >&2 echo `# Finally break the line of dots` ; \
) | cut -d '-' -f 1 | sort --version-sort | uniq;

Sample output:

$ url=https://registry.hub.docker.com/v2/repositories/library/redis/tags/?page_size=100 `#initial url` ; \
> ( \
>   while [ ! -z $url ]; do `#Keep looping until the variable url is empty` \
>     >&2 echo -n "." `#Every iteration of the loop prints out a single dot to show progress as it got through all the pages (this is inline dot)` ; \
>     content=$(curl -s $url | python -c 'import sys, json; data = json.load(sys.stdin); print(data.get("next", "") or ""); print("\n".join([x["name"] for x in data["results"]]))') `# Curl the URL and pipe the JSON to Python. Python will parse the JSON and print the very first line as the next URL (it will leave it blank if there are no more pages) then continue to loop over the results extracting only the name; all will be store in a variable called content` ; \
>     url=$(echo "$content" | head -n 1) `#Let's get the first line of content which contains the next URL for the loop to continue` ; \
>     echo "$content" | tail -n +2 `#Print the content with out the first line (yes +2 is counter intuitive)` ; \
>   done; \
>   >&2 echo `#Finally break the line of dots` ; \
> ) | cut -d '-' -f 1 | sort --version-sort | uniq;
...
2
2.6
2.6.17
2.8
2.8.6
2.8.7
2.8.8
2.8.9
2.8.10
2.8.11
2.8.12
2.8.13
2.8.14
2.8.15
2.8.16
2.8.17
2.8.18
2.8.19
2.8.20
2.8.21
2.8.22
2.8.23
3
3.0
3.0.0
3.0.1
3.0.2
3.0.3
3.0.4
3.0.5
3.0.6
3.0.7
3.0.504
3.2
3.2.0
3.2.1
3.2.2
3.2.3
3.2.4
3.2.5
3.2.6
3.2.7
3.2.8
3.2.9
3.2.10
3.2.11
3.2.100
4
4.0
4.0.0
4.0.1
4.0.2
4.0.4
4.0.5
4.0.6
4.0.7
4.0.8
32bit
alpine
latest
nanoserver
windowsservercore

If you want the bash_profile version:

function docker-tags () {
  name=$1
  # Initial URL
  url=https://registry.hub.docker.com/v2/repositories/library/$name/tags/?page_size=100
  (
    # Keep looping until the variable URL is empty
    while [ ! -z $url ]; do
      # Every iteration of the loop prints out a single dot to show progress as it got through all the pages (this is inline dot)
      >&2 echo -n "."
      # Curl the URL and pipe the output to Python. Python will parse the JSON and print the very first line as the next URL (it will leave it blank if there are no more pages)
      # then continue to loop over the results extracting only the name; all will be stored in a variable called content
      content=$(curl -s $url | python -c 'import sys, json; data = json.load(sys.stdin); print(data.get("next", "") or ""); print("\n".join([x["name"] for x in data["results"]]))')
      # Let's get the first line of content which contains the next URL for the loop to continue
      url=$(echo "$content" | head -n 1)
      # Print the content without the first line (yes +2 is counter intuitive)
      echo "$content" | tail -n +2
    done;
    # Finally break the line of dots
    >&2 echo
  ) | cut -d '-' -f 1 | sort --version-sort | uniq;
}

And simply call it: docker-tags redis

Sample output:

$ docker-tags redis
...
2
2.6
2.6.17
2.8

--trunc----

32bit
alpine
latest
nanoserver
windowsservercore

Upvotes: 19

Mark Riggins

Reputation: 195

For a script that works with OAuth bearer tokens on Docker Hub, try this:

Listing the tags of a Docker image on a Docker hub through the HTTP API

Upvotes: 0

Hari Sekhon

Reputation: 91

I wrote a command line tool to simplify searching Docker Hub repository tags, available in my PyTools GitHub repository. It's simple to use with various command line switches, but most basically:

./dockerhub_show_tags.py repo1 repo2

It's even available as a Docker image and can take multiple repositories:

docker run harisekhon/pytools dockerhub_show_tags.py centos ubuntu

DockerHub

repo: centos
tags: 5.11
      6.6
      6.7
      7.0.1406
      7.1.1503
      centos5.11
      centos6.6
      centos6.7
      centos7.0.1406
      centos7.1.1503

repo: ubuntu
tags: latest
      14.04
      15.10
      16.04
      trusty
      trusty-20160503.1
      wily
      wily-20160503
      xenial
      xenial-20160503

If you want to embed it in scripts, use -q / --quiet to get just the tags, like normal Docker commands:

./dockerhub_show_tags.py centos -q
5.11
6.6
6.7
7.0.1406
7.1.1503
centos5.11
centos6.6
centos6.7
centos7.0.1406
centos7.1.1503

Upvotes: 6

Chris Cheetham

Reputation: 16

Reimplementation of the previous post, using Python over sed/AWK:

for Repo in $* ; do
    tags=$(curl -s -S "https://registry.hub.docker.com/v2/repositories/library/$Repo/tags/")
    python - <<EOF

import json

tags = [t['name'] for t in json.loads('''$tags''')['results']]
tags.sort()
for tag in tags:
    print "{}:{}".format('$Repo', tag)
EOF
done

Upvotes: 0

shadowbq

Reputation: 1459

When using CoreOS, jq is available to parse JSON data.

So like you were doing before, looking at library/centos:

$ curl -s -S 'https://registry.hub.docker.com/v2/repositories/library/centos/tags/' | jq '."results"[]["name"]' |sort
"6"
"6.7"
"centos5"
"centos5.11"
"centos6"
"centos6.6"
"centos6.7"
"centos7.0.1406"
"centos7.1.1503"
"latest"

The cleaner v2 API is available now, and that's what I'm using in the example. I will build a simple script docker_remote_tags:

#!/usr/bin/bash
curl -s -S "https://registry.hub.docker.com/v2/repositories/library/$@/tags/" | jq '."results"[]["name"]' |sort

Enables:

$ ./docker_remote_tags library/centos
"6"
"6.7"
"centos5"
"centos5.11"
"centos6"
"centos6.6"
"centos6.7"
"centos7.0.1406"
"centos7.1.1503"
"latest"

Reference:

jq: https://stedolan.github.io/jq/ | apt-get install jq

Upvotes: 43

Abel Muiño

Reputation: 7761

As far as I know, the CLI does not allow searching/listing tags in a repository.

But if you know which tag you want, you can pull that explicitly by adding a colon and the image name: docker pull ubuntu:saucy

Upvotes: 12

How can I find a Docker image with a specific tag in Docker registry on the Docker command line?

Answers (13)

Related Questions