¿Cómo puedo enumerar todas las etiquetas para una imagen de Docker en un registro remoto?

¿Cómo puedo enumerar todas las etiquetas de una imagen de Docker en un registro remoto de Docker usando la CLI (preferida) o curl?

Preferiblemente sin extraer todas las versiones del registro remoto. Solo quiero enumerar las etiquetas.

Tengo la respuesta de aquí . ¡Muchas gracias! :)

Solo script de una línea: (encuentre todas las etiquetas 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}'

ACTUALIZACIÓN Gracias por el consejo de @degelf. Aquí está el script de 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}"

Puede crear un nuevo nombre de archivo dockertags, debajo de / usr / local / bin (o agregar un PATH env a su .bashrc/ .zshrc), y poner ese código en él. Luego agregue los permisos ejecutables ( chmod +x dockertags).

Uso:

dockertags ubuntu ---> enumera todas las etiquetas de ubuntu

dockertags php apache ---> enumera todas las etiquetas php php que contienen 'apache'

A partir de Docker Registry V2, GETbasta con un simple :

GET /v2/<name>/tags/list

Ver documentos para más.

Si desea utilizar la API de Docker Registry v2, enumera las etiquetas por páginas. Para enumerar todas las etiquetas de una imagen, es posible que desee agregar un parámetro de tamaño de página grande a la URL, por ejemplo

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

La API de Docker V2 requiere un token portador de OAuth con las notificaciones correspondientes. En mi opinión, la documentación oficial es bastante vaga sobre el tema. Para que otros no pasen por el mismo dolor que yo, ofrezco la siguiente docker-tagsfunción.

La versión más reciente de docker-tagsse puede encontrar en mi GitHubGist: "Listar etiquetas de imagen de Docker usando bash" .

La función docker-tags depende de jq . Si estás jugando con JSON, es probable que ya lo tengas.

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

Ejemplo

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

Es cierto que docker-tagshace varias suposiciones. Específicamente, los parámetros de solicitud de OAuth están en su mayoría codificados. Una implementación más ambiciosa haría una solicitud no autenticada al registro y derivaría los parámetros OAuth de la respuesta no autenticada.

Me las arreglé para que funcione usando curl:

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

Tenga en cuenta que image_nameno debe contener detalles del usuario, etc. Por ejemplo, si está presionando una imagen con nombre tutum.co/username/x, image_namedebería estarlo x.

Sobre la base de la respuesta de Yan Foto (la api v2 ), creé un script simple de Python para enumerar las etiquetas de una imagen determinada .

Uso:

./docker-registry-list.py alpine

Salida:

{
  "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 la herramienta de análisis JSON jqestá disponible

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

Consulte la utilidad CLI: https://www.npmjs.com/package/docker-browse

Permite la enumeración de etiquetas e imágenes.

docker-browse tags <image>enumerará todas las etiquetas para la imagen. p.ejdocker-browse tags library/alpine

docker-browse imagesenumerará todas las imágenes en el registro. Actualmente no disponible para index.docker.io.

Puede conectarlo a cualquier registro, incluido el privado, siempre que sea compatible con Docker Registry HTTP API V2

Para ver todas las etiquetas disponibles en un navegador:

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

es decir, https://hub.docker.com/r/localstack/localstack/tags

O bien, puede obtener una respuesta json utilizando este punto final:

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

También puedes usar este scrap:

# vim /usr/sbin/docker-tags 

& Añadir lo siguiente (como está):

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

Hazlo ejecutable:

# chmod 755 /usr/sbin/docker-tags

Entonces finalmente intente con:

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

$ docker search ubuntu

$ docker-tags teamrock/ubuntu
   latest

[Espero que esté al tanto de $ & # antes de ejecutar cualquier comando]

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'

Puede usarlo si su env no tiene 'jq', =)

Obtenga todas las etiquetas de Docker Hub: este comando utiliza el JSONprocesador de línea de comandos jqpara seleccionar los nombres de etiqueta de los JSONdevueltos por el Registro de Docker Hub (las comillas se eliminan con tr). Reemplace la biblioteca con el nombre de usuario de Docker Hub, debian con el nombre de la imagen:

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

Aquí hay un script de Powershell que escribí para Windows. Maneja repositorios v1 y 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
}

Puede lograrlo ejecutando en la terminal esto:

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

Además, si no tiene jq, debe instalarlo

sudo apt-get install jq

He hecho esto cuando tengo que implementar una tarea en la que si el usuario de alguna manera escribe la etiqueta incorrecta, entonces tenemos que dar la lista de todas las etiquetas presentes en el repositorio (repositorio de Docker) presente en el registro. Así que tengo código en secuencia de comandos por lotes.

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

Entonces, en esto podemos dar argumentos para el archivo por lotes como:

Dockerfile java version7 

La API de registro de Docker tiene un punto final para enumerar todas las etiquetas .

Parece que Tutum tiene un punto final similar , así como una forma de acceder a través de tutum-cli .

Con el tutum-cli, intente lo siguiente:

tutum tag list <uuid>

En powershell 5.1, tengo un script simple list_docker_image_tags.ps1 como este:

[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

Entonces puedo buscar 4.7 etiquetas como esta:

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

Puede enumerar todas las etiquetas con 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"
]

Para registros externos:

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

Si la gente quiere leer las etiquetas del registro de RedHat, https://registry.redhat.io/v2entonces los pasos son:

# 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 desea comparar lo que tiene en su registro de OpenShift local con lo que está en el registro ascendente.redhat.com, aquí hay un script completo .