Comment répertorier toutes les balises d'une image Docker sur un registre distant?

Comment puis-je répertorier toutes les balises d'une image Docker sur un registre Docker distant en utilisant la CLI (préférée) ou curl?

De préférence sans extraire toutes les versions du registre distant. Je veux juste lister les tags.

J'ai obtenu la réponse d' ici . Merci beaucoup! :)

Un script sur une seule ligne: (trouvez toutes les balises de 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}'

MISE À JOUR Merci pour les conseils de @ degelf. Voici le script shell.

#!/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}"

Vous pouvez simplement créer un nouveau nom de fichier dockertags, sous / usr / local / bin (ou ajouter un envoi PATH à votre .bashrc/ .zshrc), et y mettre ce code. Ajoutez ensuite les autorisations exécutables ( chmod +x dockertags).

Usage:

dockertags ubuntu ---> liste de toutes les balises de ubuntu

dockertags php apache ---> liste de toutes les balises php php contenant 'apache'

Depuis Docker Registry V2, un simple GETsuffixe:

GET /v2/<name>/tags/list

Consultez la documentation pour en savoir plus.

Si vous souhaitez utiliser l'API Docker Registry v2, il répertorie les balises par pages. Pour lister toutes les balises d'une image, vous voudrez peut-être ajouter un grand paramètre page_size à l'url, par exemple

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

L'API Docker V2 nécessite un jeton de support OAuth avec les revendications appropriées. À mon avis, la documentation officielle est assez vague sur le sujet. Pour que les autres ne subissent pas la même douleur que moi, j'offre la docker-tagsfonction ci-dessous .

La version la plus récente de docker-tagspeut être trouvée dans mon GitHubGist: "List Docker Image Tags using bash" .

La fonction docker-tags dépend de jq . Si vous jouez avec JSON, vous l'avez probablement déjà.

#!/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
}

Exemple

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

Certes, docker-tagsfait plusieurs hypothèses. Plus précisément, les paramètres de demande OAuth sont pour la plupart codés en dur. Une mise en œuvre plus ambitieuse ferait une demande non authentifiée au registre et dériverait les paramètres OAuth de la réponse non authentifiée.

J'ai réussi à le faire fonctionner en utilisant curl:

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

Notez que cela image_namene devrait pas contenir de détails sur l'utilisateur, etc. Par exemple, si vous poussez l'image nommée, tutum.co/username/xelle image_namedevrait l'être x.

S'appuyant sur la réponse de Yan Foto (l' API v2 ), j'ai créé un simple script Python pour répertorier les balises d'une image donnée .

Usage:

./docker-registry-list.py alpine

Production:

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

Si l'outil d'analyse JSON jqest disponible

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

Voir l'utilitaire CLI: https://www.npmjs.com/package/docker-browse

Permet l'énumération des tags et des images.

docker-browse tags <image>répertorie toutes les balises de l'image. par exempledocker-browse tags library/alpine

docker-browse imagesrépertorie toutes les images du registre. Non disponible actuellement pour index.docker.io.

Vous pouvez le connecter à n'importe quel registre, y compris votre registre privé, tant qu'il prend en charge Docker Registry HTTP API V2

Pour afficher toutes les balises disponibles dans un navigateur:

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

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

Ou, vous pouvez obtenir une réponse json en utilisant ce point de terminaison:

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

Vous pouvez également utiliser ce scrap:

# vim /usr/sbin/docker-tags 

& Ajouter ce qui suit (tel quel):

#!/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

Rendez-le exécutable:

# chmod 755 /usr/sbin/docker-tags

Puis enfin essayez par:

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

$ docker search ubuntu

$ docker-tags teamrock/ubuntu
   latest

[J'espère que vous connaissez $ & # avant d'exécuter une commande]

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'

Vous pouvez l'utiliser si votre env n'a pas de 'jq', =)

Obtenir toutes les balises de Docker Hub: cette commande utilise le JSONprocesseur de ligne de commande jqpour sélectionner les noms de balise parmi ceux JSONrenvoyés par le Docker Hub Registry (les guillemets sont supprimés avec tr). Remplacez la bibliothèque par le nom d'utilisateur Docker Hub, debian par le nom de l'image:

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

Voici un script Powershell que j'ai écrit pour Windows. Gère les dépôts v1 et 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
}

Vous pouvez y parvenir en exécutant sur le terminal ceci:

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

De plus, si vous n'avez pas jq, vous devez l'installer en

sudo apt-get install jq

J'ai fait cette chose lorsque je dois implémenter une tâche dans laquelle si l'utilisateur tape en quelque sorte la mauvaise balise, nous devons donner la liste de toutes les balises présentes dans le référentiel (Docker repo) présentes dans le registre. J'ai donc du code dans le script batch.

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

Ainsi, nous pouvons donner des arguments pour sortir le fichier batch comme:

Dockerfile java version7 

L'API Docker Registry a un point de terminaison pour répertorier toutes les balises .

On dirait que Tutum a un point de terminaison similaire , ainsi qu'un moyen d'accéder via tutum-cli .

Avec le tutum-cli, essayez ce qui suit:

tutum tag list <uuid>

Dans powershell 5.1, j'ai un simple script list_docker_image_tags.ps1 comme celui-ci:

[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

Ensuite, je peux rechercher des balises 4.7 comme ceci:

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

Vous pouvez lister toutes les balises avec skopeo .

அ  ~  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"
]

Pour les registres externes:

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

Si les gens veulent lire les balises du registre RedHat à, https://registry.redhat.io/v2les étapes sont les suivantes:

# 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"[]' 

Si vous souhaitez comparer ce que vous avez dans votre registre openshift local avec ce qui se trouve dans le registre amont.redhat.com, voici un script complet .