Quay.io : registry sécurisée avec scan Clair et robot accounts

Vous cherchez une alternative à Docker Hub avec un scan de sécurité intégré et des dépôts privés illimités ? Quay.io est la registry de conteneurs de Red Hat, connue pour son scanner Clair et ses robot accounts — des comptes de service parfaits pour l’automatisation CI/CD.

Ce que vous allez apprendre

Ce guide couvre l’ensemble du workflow Quay.io, de la création de compte jusqu’à l’intégration complète dans vos pipelines de déploiement.

• Créer un compte et comprendre les plans (gratuit vs payant)
• Configurer un robot account pour l’authentification CI/CD
• Scanner vos images avec Clair (vulnérabilités CVE)
• Publier une image avec docker push vers quay.io
• Automatiser vos builds avec GitHub Actions
• Gérer les équipes et permissions dans une organisation

Prérequis

Comprendre les registries de conteneurs Vocabulaire, fonctionnement de docker pull/push, standards OCI

Écrire un Dockerfile Créer votre première image Docker

Qu’est-ce que Quay.io ?

Quay.io est la registry cloud de Red Hat, lancée en 2013 par CoreOS puis acquise par Red Hat en 2018. Elle stocke et distribue des images de conteneurs au format OCI, comme Docker Hub, mais avec une orientation sécurité plus marquée.

Pourquoi choisir Quay.io ?

Critère	Docker Hub	Quay.io
Scan de sécurité	Docker Scout (payant)	Clair intégré (gratuit)
Dépôts privés	1 gratuit	Illimités (publics)
Robot accounts	❌ Non	✅ Oui, natif
Rate limiting	100 pulls/h (gratuit)	Pas de limite documentée
Geo-replication	❌ Non	✅ Oui (self-hosted)
Builds automatisés	❌ Supprimé	✅ Oui

Glissez pour voir

Analogie : si Docker Hub est comme GitHub (grand public, communauté), Quay.io est comme GitLab (plus orienté entreprise, sécurité intégrée, self-hosting possible).

Clair : le scanner de vulnérabilités

Le différenciateur majeur de Quay.io est Clair, un scanner open source qui analyse chaque layer de vos images pour détecter les CVE (Common Vulnerabilities and Exposures). Le scan est automatique : dès que vous poussez une image, Clair l’analyse et affiche les résultats dans l’interface.

Clair agrège les données de plusieurs sources de vulnérabilités :

• NVD (National Vulnerability Database)
• Red Hat Security Data
• Debian Security Tracker
• Ubuntu CVE Tracker
• Alpine SecDB

Scan vs correction

Clair détecte les vulnérabilités mais ne les corrige pas automatiquement. C’est à vous de mettre à jour votre image de base ou les paquets concernés. Utilisez les résultats pour prioriser vos corrections par sévérité (Critical, High, Medium, Low).

Créer un compte Quay.io

1. Accéder au site

   Rendez-vous sur quay.io et cliquez sur Sign In puis Create Account.

2. Choisir une méthode d’authentification

   Quay.io propose plusieurs options :

   • Compte Red Hat (recommandé si vous utilisez OpenShift)
   • Compte GitHub (pratique pour lier vos repos)
   • Email + mot de passe (classique)

3. Confirmer votre email

   Vérifiez votre boîte mail et cliquez sur le lien de confirmation.

4. Accéder au tableau de bord

   Vous arrivez sur votre dashboard avec vos repositories (vides pour l’instant).

Plans et tarification

Quay.io propose plusieurs formules adaptées aux besoins individuels et aux équipes. Le plan gratuit est généreux pour les projets open source avec des dépôts publics illimités.

Plan	Dépôts privés	Dépôts publics	Équipes	Prix
Free	0	Illimités	❌	Gratuit
Developer	5	Illimités	❌	$15/mois
Micro	10	Illimités	✅	$30/mois
Small	20	Illimités	✅	$50/mois
Large	50	Illimités	✅	$100/mois

Glissez pour voir

Tous les plans incluent

Quel que soit votre plan, vous bénéficiez du scan Clair, des robot accounts, du chiffrement SSL/TLS, des logs d’audit et de l’intégration CI/CD.

Configurer un robot account

Les robot accounts sont des comptes de service dédiés à l’automatisation. Contrairement à votre compte personnel, ils n’ont pas de mot de passe à expiration et peuvent avoir des permissions limitées à certains repositories.

Pourquoi utiliser un robot account ?

Les robot accounts offrent plusieurs avantages par rapport à l’utilisation de vos identifiants personnels dans les pipelines CI/CD :

Critère	Compte personnel	Robot account
Révocation	Bloque tous vos accès	Révocable individuellement
Permissions	Accès total	Limité à certains repos
Audit	Difficile à tracer	Activité séparée
Partage	Risque de fuite	Conçu pour être partagé
Expiration	Mot de passe à gérer	Token permanent (révocable)

Glissez pour voir

Créer un robot account

1. Accéder aux paramètres du repository

   Allez sur votre repository → Settings → Robot Accounts.

2. Créer le robot

   Cliquez sur Create Robot Account :

   • Name : nom descriptif (ex: github_actions_push, kubernetes_pull)
   • Le nom complet sera : votre-user+nom_robot ou votre-org+nom_robot

3. Définir les permissions

   Pour chaque repository, choisissez :

   • None : aucun accès
   • Read : docker pull uniquement
   • Write : docker pull + docker push
   • Admin : accès complet + gestion du repo

4. Récupérer les credentials

   Quay.io génère automatiquement :

   • Username : votre-user+nom_robot
   • Token : chaîne longue à copier immédiatement

   Le token n’est affiché qu’une seule fois (comme les PAT Docker Hub).

5. Tester la connexion

   # Connexion avec le robot account
   docker login quay.io -u "votre-user+github_actions_push" -p "TOKEN"
   
   # Résultat attendu
   Login Succeeded

Format du username

Le username d’un robot account contient un + qui peut poser problème dans certains shells. Encadrez-le toujours de guillemets : "votre-user+robot_name".

Publier une image sur Quay.io

Le workflow est similaire à Docker Hub, avec un préfixe de registry différent.

Préparer et taguer l’image

# 1. Construire l'image localement
docker build -t monapp:v1.0.0 .

# 2. Taguer pour Quay.io
# Format : quay.io/namespace/repository:tag
docker tag monapp:v1.0.0 quay.io/mon-user/monapp:v1.0.0

# Optionnel : ajouter le tag latest
docker tag monapp:v1.0.0 quay.io/mon-user/monapp:latest

Pousser l’image

# 3. Se connecter (avec robot account recommandé)
docker login quay.io -u "mon-user+ci_push" -p "$QUAY_TOKEN"

# 4. Pousser l'image
docker push quay.io/mon-user/monapp:v1.0.0
docker push quay.io/mon-user/monapp:latest

Résultat attendu :

The push refers to repository [quay.io/mon-user/monapp]
a3b52c...: Pushed
b4c63d...: Pushed
v1.0.0: digest: sha256:abc123... size: 1234

Vérifier le scan de sécurité

Après le push, Quay.io lance automatiquement le scan Clair. Rendez-vous sur https://quay.io/repository/mon-user/monapp → onglet Tags → colonne Security Scan.

Les résultats affichent :

• Passed (vert) : aucune vulnérabilité critique/haute
• Warning (orange) : vulnérabilités medium/low
• Failed (rouge) : vulnérabilités critiques ou hautes détectées

Automatiser avec GitHub Actions

Voici un workflow complet pour builder, scanner et pousser vos images vers Quay.io à chaque commit.

Pourquoi piner les actions par SHA ?

Les tags comme @v4 peuvent être déplacés par le mainteneur de l’action. Un attaquant qui compromet le compte pourrait remplacer le code de @v4 par du code malveillant. En pinant par SHA (ex: @11bd71901...), vous utilisez une version immuable — le code ne peut pas changer sans que le SHA change.

Configurer les secrets GitHub

Pour permettre à GitHub Actions de pousser vers Quay.io, créez des secrets dans votre repository GitHub. Ces secrets sont chiffrés et injectés uniquement au runtime du workflow.

Dans votre repo GitHub : Settings → Secrets and variables → Actions → New repository secret :

Secret	Valeur
QUAY_USERNAME	votre-user+robot_name (avec le +)
QUAY_TOKEN	Le token du robot account

Glissez pour voir

Workflow GitHub Actions

Créez .github/workflows/quay-publish.yml :

name: Build and Push to Quay.io

on:
  push:
    branches: [main]
    tags: ['v*']
  pull_request:
    branches: [main]

env:
  REGISTRY: quay.io
  IMAGE_NAME: ${{ github.repository }}

jobs:
  build-and-push:
    runs-on: ubuntu-latest
    permissions:
      contents: read

    steps:
      # Toutes les actions sont pinées par SHA pour la sécurité
      - name: Checkout code
        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@988b5a0280414f521da01fcc63a27aeeb4b104db # v3.6.1

      - name: Login to Quay.io
        if: github.event_name != 'pull_request'
        uses: docker/login-action@9780b0c442fbb1117ed29e0efdff1e18412f7567 # v3.3.0
        with:
          registry: quay.io
          username: ${{ secrets.QUAY_USERNAME }}
          password: ${{ secrets.QUAY_TOKEN }}

      - name: Extract metadata (tags, labels)
        id: meta
        uses: docker/metadata-action@8e5442c4ef9f78752691e2d8f8d19755c6f78e81 # v5.5.1
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
          tags: |
            type=ref,event=branch
            type=semver,pattern={{version}}
            type=sha,prefix=

      - name: Build and push
        uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
        with:
          context: .
          push: ${{ github.event_name != 'pull_request' }}
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=gha
          cache-to: type=gha,mode=max

Ce que fait ce workflow

1. Checkout : récupère le code source du repository
2. Buildx : configure le builder Docker moderne avec support du cache
3. Login : s’authentifie avec le robot account (sauf pour les PR)
4. Metadata : génère les tags automatiquement (main, v1.2.3, sha-abc123)
5. Build & Push : construit l’image multi-plateforme et la pousse vers Quay.io

Le scan Clair se déclenche automatiquement après le push — pas besoin d’action supplémentaire.

Gérer les organisations et équipes

Pour les projets d’équipe, Quay.io propose des organisations avec une gestion fine des permissions par équipe et par repository.

Créer une organisation

1. Quay.io → + (menu) → New Organization
2. Choisissez un nom (ex: mon-entreprise)
3. Sélectionnez le plan (Micro minimum pour les équipes)

Configurer les équipes et permissions

Le modèle de permissions de Quay.io suit le principe du moindre privilège. Créez des équipes par fonction et assignez-leur des rôles spécifiques sur chaque repository.

Rôle	Permissions
Creator	Créer de nouveaux repositories dans l’organisation
Admin	Accès total au repository (settings, permissions, suppression)
Write	Pull + Push d’images
Read	Pull uniquement

Glissez pour voir

Exemple de structure :

Organisation: mon-entreprise
├── Team: backend-devs
│   ├── Rôle: Write sur mon-entreprise/api-*
│   └── Membres: alice, bob
├── Team: devops
│   ├── Rôle: Admin sur tous les repos
│   └── Membres: charlie
├── Team: qa
│   ├── Rôle: Read sur tous les repos
│   └── Membres: diana
└── Robot: mon-entreprise+ci_deploy
    └── Rôle: Write sur mon-entreprise/prod-*

Repository mirroring

Quay.io permet de synchroniser automatiquement des images depuis d’autres registries (Docker Hub, gcr.io, ECR…). Cette fonctionnalité est utile pour avoir une copie locale de vos dépendances.

Cas d’usage du mirroring

Le mirroring résout plusieurs problèmes opérationnels courants :

• Contourner le rate limiting de Docker Hub
• Garantir la disponibilité en cas de panne de la source
• Scanner les images externes avec Clair avant utilisation
• Respecter les politiques de sécurité (pas d’accès direct à Internet)

Configurer un mirror

1. Créer un repository de type “Mirror”

   Repository → Settings → Repository State → Mirror

2. Configurer la source

   • External Registry : docker.io/library/nginx
   • Sync Interval : fréquence de synchronisation (ex: 1h)
   • Robot Account : compte pour l’authentification si la source est privée

3. Définir les tags à synchroniser

   Utilisez des patterns : v1.*, latest, stable

4. Activer la synchronisation

   Le premier sync peut prendre du temps selon la taille des images.

Intégration Kubernetes

Pour tirer des images depuis Quay.io dans Kubernetes, créez un Secret de type docker-registry.

Créer le Secret

kubectl create secret docker-registry quay-secret \
  --docker-server=quay.io \
  --docker-username="mon-org+k8s_pull" \
  --docker-password="$QUAY_TOKEN" \
  --docker-email=devops@example.com \
  -n mon-namespace

Utiliser le Secret dans un Pod

apiVersion: v1
kind: Pod
metadata:
  name: mon-app
spec:
  containers:
    - name: app
      image: quay.io/mon-org/monapp:v1.0.0
  imagePullSecrets:
    - name: quay-secret

ServiceAccount par défaut

Pour éviter de répéter imagePullSecrets dans chaque Pod, attachez le Secret au ServiceAccount default du namespace :

kubectl patch serviceaccount default \
  -p '{"imagePullSecrets": [{"name": "quay-secret"}]}' \
  -n mon-namespace

Dépannage

Voici les erreurs les plus fréquentes lors de l’utilisation de Quay.io et leurs solutions. La majorité des problèmes viennent de l’authentification ou des permissions.

Symptôme	Cause probable	Solution
unauthorized: access denied	Robot account sans permission	Vérifier les permissions Write sur le repo
denied: requested access is denied	Mauvais namespace	Vérifier quay.io/user/repo vs quay.io/org/repo
name unknown: repository not found	Repo inexistant	Créer le repo manuellement ou activer auto-create
Error: Invalid username/password	Token expiré ou mal copié	Régénérer le token du robot account
Scan bloqué sur “Queued”	Image trop grosse ou service surchargé	Attendre ou repousser l’image

Glissez pour voir

À retenir

1. Quay.io est l’alternative Red Hat à Docker Hub, avec un focus sécurité. Le scan Clair est inclus gratuitement et analyse chaque image automatiquement.

2. Les robot accounts sont essentiels pour la CI/CD. Créez-en un par usage (CI push, Kubernetes pull) avec les permissions minimales nécessaires.

3. Le format du registry est quay.io/namespace/repo:tag. N’oubliez pas le préfixe quay.io dans vos tags et manifests Kubernetes.

4. Le mirroring permet de cacher les images externes et de contourner le rate limiting de Docker Hub tout en bénéficiant du scan Clair.

5. Pinz vos actions GitHub par SHA pour la sécurité supply chain. Les tags comme @v4 peuvent être déplacés par un attaquant.

Prochaines étapes

Docker Hub : la registry publique Alternative plus simple pour les projets publics

Harbor : registry on-premise Déployer votre propre registry avec scan et RBAC

Scanner vos images avec Trivy Alternative open source à Clair, multi-registries

Kubernetes : premiers pas Déployer vos images sur un cluster

×

📖 Voir la documentation →