Wie kann ich alle Tags für ein Docker-Image in einer Remote-Registrierung auflisten?

Wie kann ich alle Tags eines Docker-Images in einer Remote-Docker-Registrierung mithilfe der CLI (bevorzugt) oder Curl auflisten?

Am besten ohne alle Versionen aus der Remote-Registrierung abzurufen. Ich möchte nur die Tags auflisten.

Ich habe die Antwort von hier bekommen . Vielen Dank! :) :)

Nur einzeiliges Skript: (finde alle Tags von debian)

wget -q https://registry.hub.docker.com/v1/repositories/debian/tags -O -  | sed -e 's/[][]//g' -e 's/"//g' -e 's/ //g' | tr '}' '\n'  | awk -F: '{print $3}'

UPDATE Vielen Dank für den Rat von @ degelf. Hier ist das Shell-Skript.

#!/bin/bash

if [ $# -lt 1 ]
then
cat << HELP

dockertags  --  list all tags for a Docker image on a remote registry.

EXAMPLE: 
    - list all tags for ubuntu:
       dockertags ubuntu

    - list all php tags containing apache:
       dockertags php apache

HELP
fi

image="$1"
tags=`wget -q https://registry.hub.docker.com/v1/repositories/${image}/tags -O -  | sed -e 's/[][]//g' -e 's/"//g' -e 's/ //g' | tr '}' '\n'  | awk -F: '{print $3}'`

if [ -n "$2" ]
then
    tags=` echo "${tags}" | grep "$2" `
fi

echo "${tags}"

Sie können einfach einen neuen Dateinamen dockertagsunter / usr / local / bin erstellen (oder Ihrem .bashrc/ eine PATH-Umgebung hinzufügen .zshrc) und diesen Code einfügen. Fügen Sie dann die ausführbaren Berechtigungen ( chmod +x dockertags) hinzu.

Verwendung:

dockertags ubuntu ---> liste alle Tags von Ubuntu auf

dockertags php apache ---> liste alle PHP-Tags auf, die 'Apache' enthalten

Ab Docker Registry V2 reicht ein einfaches GETaus:

GET /v2/<name>/tags/list

Weitere Informationen finden Sie in den Dokumenten .

Wenn Sie die Docker-Registrierungs-v2-API verwenden möchten, werden Tags nach Seiten aufgelistet. Um alle Tags eines Bildes aufzulisten, möchten Sie der URL möglicherweise einen großen Parameter page_size hinzufügen, z

curl -L -s 'https://registry.hub.docker.com/v2/repositories/library/centos/tags?page_size=1024'|jq '."results"[]["name"]'

Die Docker V2-API erfordert ein OAuth-Inhaber-Token mit den entsprechenden Ansprüchen. Meiner Meinung nach ist die offizielle Dokumentation zu diesem Thema eher vage. Damit andere nicht die gleichen Schmerzen haben wie ich, biete ich die folgende docker-tagsFunktion an.

Die neueste Version von docker-tagsbefindet sich in meinem GitHubGist: "List Docker Image Tags using bash" .

Die Docker-Tags-Funktion ist von jq abhängig . Wenn Sie mit JSON spielen, haben Sie es wahrscheinlich bereits.

#!/usr/bin/env bash
docker-tags() {
    arr=("$@")

    for item in "${arr[@]}";
    do
        tokenUri="https://auth.docker.io/token"
        data=("service=registry.docker.io" "scope=repository:$item:pull")
        token="$(curl --silent --get --data-urlencode ${data[0]} --data-urlencode ${data[1]} $tokenUri | jq --raw-output '.token')"
        listUri="https://registry-1.docker.io/v2/$item/tags/list"
        authz="Authorization: Bearer $token"
        result="$(curl --silent --get -H "Accept: application/json" -H "Authorization: Bearer $token" $listUri | jq --raw-output '.')"
        echo $result
    done
}

Beispiel

docker-tags "microsoft/nanoserver" "microsoft/dotnet" "library/mongo" "library/redis"

Zugegeben, docker-tagsmacht mehrere Annahmen. Insbesondere sind die OAuth-Anforderungsparameter meist fest codiert. Eine ehrgeizigere Implementierung würde eine nicht authentifizierte Anforderung an die Registrierung senden und die OAuth-Parameter aus der nicht authentifizierten Antwort ableiten.

Ich habe es geschafft, es mit Curl zum Laufen zu bringen:

curl -u <username>:<password> https://tutum.co/v1/repositories/<username>/<image_name>/tags

Beachten Sie, dass image_namedies keine Benutzerdetails usw. enthalten sollte . Wenn Sie beispielsweise ein Bild mit dem Namen tutum.co/username/xpushen, image_namesollte dies der Fall sein x.

Aufbauend auf der Antwort von Yan Foto (der v2-API ) habe ich ein einfaches Python-Skript erstellt, um die Tags für ein bestimmtes Bild aufzulisten .

Verwendung:

./docker-registry-list.py alpine

Ausgabe:

{
  "name": "library/alpine",
  "tags": [
    "2.6",
    "2.7",
    "3.1",
    "3.2",
    "3.3",
    "3.4",
    "3.5",
    "3.6",
    "3.7",
    "edge",
    "latest"
  ]
}

Wenn das JSON-Parsing-Tool jqverfügbar ist

wget -q https://registry.hub.docker.com/v1/repositories/debian/tags -O - | \
    jq -r '.[].name'

Siehe CLI-Dienstprogramm: https://www.npmjs.com/package/docker-browse

Ermöglicht die Aufzählung von Tags und Bildern.

docker-browse tags <image>listet alle Tags für das Bild auf. z.Bdocker-browse tags library/alpine

docker-browse imageslistet alle Bilder in der Registrierung auf. Derzeit nicht verfügbar für index.docker.io.

Sie können eine Verbindung zu einer beliebigen Registrierung herstellen, einschließlich Ihrer privaten, sofern die Docker Registry HTTP API V2 unterstützt wird

So zeigen Sie alle verfügbaren Tags in einem Browser an:

https://registry.hub.docker.com/v1/repositories/<username>/<image_name>/tags

dh https://hub.docker.com/r/localstack/localstack/tags

Mit diesem Endpunkt können Sie auch eine JSON-Antwort erhalten:

https://registry.hub.docker.com/v1/repositories/localstack/localstack/tags

Sie können diesen Schrott auch verwenden:

# vim /usr/sbin/docker-tags 

& Folgendes anhängen (wie es ist):

#!/bin/bash
im="$1"
[[ -z "$im" ]] && { echo -e '\e[31m[-]\e[39m Where is the image name ??' ; exit ; }
[[ -z "$(echo "$im"| grep -o '/')" ]] && { link="https://hub.docker.com/r/library/$im/tags/" ; } || { link="https://hub.docker.com/r/$im/tags/" ; }
resp="$(curl -sL "$link")"
err="$(echo "$resp" | grep -o 'Page Not Found')"
if [[ ! -z "$err" ]] ; then
    echo -e "\e[31m[-]\e[39m No Image Found with name => [ \e[32m$im\e[39m ]"
    exit
else
    tags="$(echo "$resp"|sed  -e 's|}|\n|g' -e 's|{|\n|g'|grep '"result"'|sed -e 's|,|\n|g'|cut -d '[' -f2|cut -d ']' -f1|sed  '/"tags":/d'|sed -e 's|"||g')"
    echo -e "\e[32m$tags\e[39m"
fi

Machen Sie es ausführbar:

# chmod 755 /usr/sbin/docker-tags

Dann probieren Sie es endlich aus:

$ docker-tags testexampleidontexist
   [-] No Image Found with name => [ testexampleidontexist ]

$ docker search ubuntu

$ docker-tags teamrock/ubuntu
   latest

[Ich hoffe, Sie kennen $ & #, bevor Sie einen Befehl ausführen]

curl -u <username>:<password> https://$your_registry/v2/$image_name/tags/list -s -o - | \
    tr -d '{' | tr -d '}' | sed -e 's/[][]//g' -e 's/"//g' -e 's/ //g' | \
    awk -F: '{print $3}' | sed -e 's/,/\n/g'

Sie können es verwenden, wenn Ihre Umgebung kein 'jq' hat, =)

Erhalten Sie alle Tags von Docker Hub: Dieser Befehl wird mit dem JSONBefehlszeilenprozessor jqden Tag - Namen aus der Auswahl JSONzurück vom Docker Hub Registry (die Anführungszeichen werden entfernt mit tr). Ersetzen Sie die Bibliothek durch den Docker Hub-Benutzernamen, debian durch den Bildnamen :

curl -s 'https://registry.hub.docker.com/v2/repositories/library/debian/tags/' | jq -r '."results"[]["name"]'

Hier ist ein Powershell-Skript, das ich für Windows geschrieben habe. Behandelt Repos der Versionen v1 und v2:

Get-DockerImageVersions.ps1:

param (
  [Parameter (Mandatory=$true)]$ImageName,
  [Parameter (Mandatory=$false)]$RegistryURL
)

if (!$RegistryURL) 
{
  $RegistryURL = "https://registry.hub.docker.com/v1/repositories"
}

$list = ""
if ($RegistryURL -like "*v2*") 
{
  $list = "/list"
}

$URL = "$RegistryURL/$ImageName/tags$list"

write-debug $URL
$resp = Invoke-WebRequest -UseBasicParsing $URL | ConvertFrom-Json

if ($RegistryURL -like "*v2*") 
{
  $tags = $resp | select tags
  $tags.tags
} else {
  $tags = $resp | select name
  $tags.name
}

Sie können dies erreichen, indem Sie auf dem Terminal Folgendes ausführen:

curl -L -s 'https://registry.hub.docker.com/v2/repositories/library/mysql/tags/' | jq . | grep name

Wenn Sie kein jq haben, müssen Sie es auch von installieren

sudo apt-get install jq

Ich habe dies getan, wenn ich eine Aufgabe implementieren muss, bei der, wenn der Benutzer irgendwie das falsche Tag eingibt, die Liste aller im Repo (Docker Repo) im Register vorhandenen Tags angegeben werden muss. Ich habe also Code im Batch-Skript.

<html>
<pre style="background-color:#bcbbbb;">
@echo off

docker login --username=xxxx --password=xxxx
docker pull %1:%2

IF NOT %ERRORLEVEL%==0 (
echo "Specified Version is Not Found "
echo "Available Version for this image is :"
for /f %%i in (' curl -s -H "Content-Type:application/json" -X POST -d "{\"username\":\"user\",\"password\":\"password\"}" https://hub.docker.com/v2/users/login ^|jq -r .token ') do set TOKEN=%%i
curl -sH "Authorization: JWT %TOKEN%" "https://hub.docker.com/v2/repositories/%1/tags/" | jq .results[].name
)
</pre>
</html>

In diesem Fall können wir unserer Batch-Datei folgende Argumente geben:

Dockerfile Java Version7 

Die Docker-Registrierungs-API verfügt über einen Endpunkt zum Auflisten aller Tags .

Tutum hat anscheinend einen ähnlichen Endpunkt sowie eine Möglichkeit, über tutum-cli darauf zuzugreifen .

Versuchen Sie mit dem Tutum-Cli Folgendes:

tutum tag list <uuid>

In Powershell 5.1 habe ich ein einfaches list_docker_image_tags.ps1- Skript wie das folgende:

[CmdletBinding()]
param (
    [Parameter(Mandatory = $true)]
    [string]
    $image
)

$url = "https://registry.hub.docker.com/v1/repositories/{0}/tags" -f $image 
Invoke-WebRequest $url  | ConvertFrom-Json | Write-Output

Dann kann ich nach 4.7 Tags wie diesen suchen:

./list_docker_image_tags.ps1 microsoft/dotnet-framework | ?{ $_.name -match "4.7" }

Sie können alle Tags mit skopeo auflisten .

அ  ~  skopeo inspect docker://httpd |jq .RepoTags
[
  "2-alpine",
  "2.2-alpine",
  "2.2.29",
  "2.2.31-alpine",
  "2.2.31",
  "2.2.32-alpine",
  "2.2.32",
  "2.2.34-alpine",
  "2.2.34",
  "2.2",
  "2.4-alpine",
  "2.4.10",
  "2.4.12",
  "2.4.16",
  "2.4.17",
  "2.4.18",
  "2.4.20",
  "2.4.23-alpine",
  "2.4.23",
  "2.4.25-alpine",
  "2.4.25",
  "2.4.27-alpine",
  "2.4.27",
  "2.4.28-alpine",
  "2.4.28",
  "2.4.29-alpine",
  "2.4.29",
  "2.4.32-alpine",
  "2.4.32",
  "2.4.33-alpine",
  "2.4.33",
  "2.4.34-alpine",
  "2.4.34",
  "2.4.35-alpine",
  "2.4.35",
  "2.4.37-alpine",
  "2.4.37",
  "2.4.38-alpine",
  "2.4.38",
  "2.4.39-alpine",
  "2.4.39",
  "2.4.41-alpine",
  "2.4.41",
  "2.4.43-alpine",
  "2.4.43",
  "2.4",
  "2",
  "alpine",
  "latest"
]

Für externe Register:

அ  ~  skopeo inspect --creds username:password docker://<registry-url>/<repo>/<image>

Wenn Leute Tags aus der RedHat-Registrierung lesen möchten, https://registry.redhat.io/v2sind die Schritte:

# example nodejs-12 image
IMAGE_STREAM=nodejs-12
REDHAT_REGISTRY_API="https://registry.redhat.io/v2/rhel8/$IMAGE_STREAM"
# Get an oAuth token based on a service account username and password https://access.redhat.com/articles/3560571
TOKEN=$(curl --silent -u "$REGISTRY_USER":"$REGISTRY_PASSWORD" "https://sso.redhat.com/auth/realms/rhcc/protocol/redhat-docker-v2/auth?service=docker-registry&client_id=curl&scope=repository:rhel:pull" |  jq --raw-output '.token')
# Grab the tags
wget -q --header="Accept: application/json" --header="Authorization: Bearer $TOKEN" -O - "$REDHAT_REGISTRY_API/tags/list" | jq -r '."tags"[]' 

Wenn Sie vergleichen möchten, was Sie in Ihrer lokalen OpenShift-Registrierung haben, mit dem, was sich in der Upstream-Registrierung befindet . Redhat.com, dann ist hier ein vollständiges Skript .