Configurer l'authentification du dépôt distant sur Docker Hub

Ce document explique comment configurer l'authentification auprès des dépôts Docker Hub en amont pour les dépôts distants Artifact Registry.

Nous vous recommandons de vous authentifier auprès de Docker Hub, même si vous n'utilisez que des images publiques, car cela augmentera votre limite de débit de téléchargement. Pour en savoir plus sur les limites de débit de téléchargement de Docker Hub, consultez la page Limite de débit de Docker Hub. Les dépôts distants vous permettent d'ajouter votre nom d'utilisateur Docker Hub et un jeton d'accès personnel enregistré en tant que secret pour l'authentification auprès de Docker Hub.

Ce document suppose que vous avez déjà créé un dépôt distant Docker Artifact Registry et un compte Docker Hub.

Pour en savoir plus sur les dépôts distants, consultez la présentation des dépôts distants.

Rôles requis

Pour obtenir les autorisations nécessaires afin de configurer l'authentification auprès de Docker Hub pour les dépôts distants, demandez à votre administrateur de vous accorder les rôles IAM suivants sur le projet :

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises avec des rôles personnalisés ou d'autres rôles prédéfinis.

Créer un jeton d'accès personnel Docker Hub

  1. Connectez-vous à Docker Hub.
  2. Créez un jeton d'accès personnel avec des autorisations en lecture seule.

  3. Copiez le jeton d'accès.

  4. Enregistrez le jeton d'accès dans un fichier texte dans votre environnement local ou Cloud Shell.

Enregistrer votre jeton d'accès personnel dans une version secrète

  1. Créez un secret dans Secret Manager.
  2. Enregistrez votre jeton d'accès personnel Docker Hub en tant que version secrète.

Accorder au compte de service Artifact Registry l'accès à votre secret

L'agent de service Artifact Registry agit au nom d'Artifact Registry lorsqu'il interagit avec Google Cloud des services. Pour autoriser l'agent de service à utiliser les secrets stockés dans Secret Manager, vous devez lui accorder l'autorisation d'afficher votre version secrète.

L'identifiant de l'agent de service est le suivant :

service-PROJECT-NUMBER@gcp-sa-artifactregistry.iam.gserviceaccount.com

PROJECT-NUMBER correspond au numéro du projet dans lequel Artifact Registry est en cours d'exécution. Google Cloud

Pour accorder à l'agent de service Artifact Registry le rôle Accesseur de secrets Secret Manager :

Console

  1. Accédez à la page Secret Manager dans la Google Cloud console.

    Accéder à la page Secret Manager

  2. Sur la page Secret Manager, cochez la case située à côté du nom du secret.

  3. S'il n'est pas déjà ouvert, cliquez sur Afficher le panneau d'informations pour ouvrir celui-ci.

  4. Dans le panneau d'informations, cliquez sur Ajouter un compte principal.

  5. Dans la zone de texte Nouveaux comptes principaux, saisissez la ou les adresses e-mail des membres à ajouter.

  6. Dans la liste déroulante Sélectionner un rôle , sélectionnez Gestionnaire de secrets , puis Accesseur de secrets Secret Manager.

gcloud

$ gcloud secrets add-iam-policy-binding secret-id \
    --member="member" \
    --role="roles/secretmanager.secretAccessor"

Où member correspond à un membre IAM, tel qu'un utilisateur, un groupe ou un compte de service.

C#

Pour vous authentifier auprès d'Artifact Registry, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 


using Google.Cloud.SecretManager.V1;
using Google.Cloud.Iam.V1;

public class IamGrantAccessSample
{
    public Policy IamGrantAccess(
      string projectId = "my-project", string secretId = "my-secret",
      string member = "user:foo@example.com")
    {
        // Create the client.
        SecretManagerServiceClient client = SecretManagerServiceClient.Create();

        // Build the resource name.
        SecretName secretName = new SecretName(projectId, secretId);

        // Get current policy.
        Policy policy = client.GetIamPolicy(new GetIamPolicyRequest
        {
            ResourceAsResourceName = secretName,
        });

        // Add the user to the list of bindings.
        policy.AddRoleMember("roles/secretmanager.secretAccessor", member);

        // Save the updated policy.
        policy = client.SetIamPolicy(new SetIamPolicyRequest
        {
            ResourceAsResourceName = secretName,
            Policy = policy,
        });
        return policy;
    }
}

Go

Pour vous authentifier auprès d'Artifact Registry, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

import (
	"context"
	"fmt"
	"io"

	secretmanager "cloud.google.com/go/secretmanager/apiv1"
)

// iamGrantAccess grants the given member access to the secret.
func iamGrantAccess(w io.Writer, name, member string) error {
	// name := "projects/my-project/secrets/my-secret"
	// member := "user:foo@example.com"

	// Create the client.
	ctx := context.Background()
	client, err := secretmanager.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("failed to create secretmanager client: %w", err)
	}
	defer client.Close()

	// Get the current IAM policy.
	handle := client.IAM(name)
	policy, err := handle.Policy(ctx)
	if err != nil {
		return fmt.Errorf("failed to get policy: %w", err)
	}

	// Grant the member access permissions.
	policy.Add(member, "roles/secretmanager.secretAccessor")
	if err = handle.SetPolicy(ctx, policy); err != nil {
		return fmt.Errorf("failed to save policy: %w", err)
	}

	fmt.Fprintf(w, "Updated IAM policy for %s\n", name)
	return nil
}

Java

Pour vous authentifier auprès d'Artifact Registry, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

import com.google.cloud.secretmanager.v1.SecretManagerServiceClient;
import com.google.cloud.secretmanager.v1.SecretName;
import com.google.iam.v1.Binding;
import com.google.iam.v1.GetIamPolicyRequest;
import com.google.iam.v1.Policy;
import com.google.iam.v1.SetIamPolicyRequest;
import java.io.IOException;

public class IamGrantAccess {

  public static void iamGrantAccess() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String secretId = "your-secret-id";
    String member = "user:foo@example.com";
    iamGrantAccess(projectId, secretId, member);
  }

  // Grant a member access to a particular secret.
  public static void iamGrantAccess(String projectId, String secretId, String member)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (SecretManagerServiceClient client = SecretManagerServiceClient.create()) {
      // Build the name from the version.
      SecretName secretName = SecretName.of(projectId, secretId);

      // Request the current IAM policy.
      Policy currentPolicy =
          client.getIamPolicy(
              GetIamPolicyRequest.newBuilder().setResource(secretName.toString()).build());

      // Build the new binding.
      Binding binding =
          Binding.newBuilder()
              .setRole("roles/secretmanager.secretAccessor")
              .addMembers(member)
              .build();

      // Create a new IAM policy from the current policy, adding the binding.
      Policy newPolicy = Policy.newBuilder().mergeFrom(currentPolicy).addBindings(binding).build();

      // Save the updated IAM policy.
      client.setIamPolicy(
          SetIamPolicyRequest.newBuilder()
              .setResource(secretName.toString())
              .setPolicy(newPolicy)
              .build());

      System.out.printf("Updated IAM policy for %s\n", secretId);
    }
  }
}

Node.js

Pour vous authentifier auprès d'Artifact Registry, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const name = 'projects/my-project/secrets/my-secret';
// const member = 'user:you@example.com';
//
// NOTE: Each member must be prefixed with its type. See the IAM documentation
// for more information: https://cloud.google.com/iam/docs/overview.

// Imports the Secret Manager library
const {SecretManagerServiceClient} = require('@google-cloud/secret-manager');

// Instantiates a client
const client = new SecretManagerServiceClient();

async function grantAccess() {
  // Get the current IAM policy.
  const [policy] = await client.getIamPolicy({
    resource: name,
  });

  // Add the user with accessor permissions to the bindings list.
  policy.bindings.push({
    role: 'roles/secretmanager.secretAccessor',
    members: [member],
  });

  // Save the updated IAM policy.
  await client.setIamPolicy({
    resource: name,
    policy: policy,
  });

  console.log(`Updated IAM policy for ${name}`);
}

grantAccess();

PHP

Pour vous authentifier auprès d'Artifact Registry, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

// Import the Secret Manager client library.
use Google\Cloud\SecretManager\V1\Client\SecretManagerServiceClient;

// Import the Secret Manager IAM library.
use Google\Cloud\Iam\V1\Binding;
use Google\Cloud\Iam\V1\GetIamPolicyRequest;
use Google\Cloud\Iam\V1\SetIamPolicyRequest;

/**
 * @param string $projectId Your Google Cloud Project ID (e.g. 'my-project')
 * @param string $secretId  Your secret ID (e.g. 'my-secret')
 * @param string $member Your member (e.g. 'user:foo@example.com')
 */
function iam_grant_access(string $projectId, string $secretId, string $member): void
{
    // Create the Secret Manager client.
    $client = new SecretManagerServiceClient();

    // Build the resource name of the secret.
    $name = $client->secretName($projectId, $secretId);

    // Get the current IAM policy.
    $policy = $client->getIamPolicy((new GetIamPolicyRequest)->setResource($name));

    // Update the bindings to include the new member.
    $bindings = iterator_to_array($policy->getBindings());
    $bindings[] = new Binding([
        'members' => [$member],
        'role' => 'roles/secretmanager.secretAccessor',
    ]);
    $policy->setBindings($bindings);

    // Build the request.
    $request = (new SetIamPolicyRequest)
        ->setResource($name)
        ->setPolicy($policy);

    // Save the updated policy to the server.
    $client->setIamPolicy($request);

    // Print out a success message.
    printf('Updated IAM policy for %s', $secretId);
}

Python

Pour vous authentifier auprès d'Artifact Registry, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

def iam_grant_access(
    project_id: str, secret_id: str, member: str
) -> iam_policy_pb2.SetIamPolicyRequest:
    """
    Grant the given member access to a secret.
    """

    # Import the Secret Manager client library.
    from google.cloud import secretmanager

    # Create the Secret Manager client.
    client = secretmanager.SecretManagerServiceClient()

    # Build the resource name of the secret.
    name = client.secret_path(project_id, secret_id)

    # Get the current IAM policy.
    policy = client.get_iam_policy(request={"resource": name})

    # Add the given member with access permissions.
    policy.bindings.add(role="roles/secretmanager.secretAccessor", members=[member])

    # Update the IAM Policy.
    new_policy = client.set_iam_policy(request={"resource": name, "policy": policy})

    # Print data about the secret.
    print(f"Updated IAM policy on {secret_id}")

Ruby

Pour vous authentifier auprès d'Artifact Registry, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

# project_id = "YOUR-GOOGLE-CLOUD-PROJECT"  # (e.g. "my-project")
# secret_id  = "YOUR-SECRET-ID"             # (e.g. "my-secret")
# member     = "USER-OR-ACCOUNT"            # (e.g. "user:foo@example.com")

# Require the Secret Manager client library.
require "google/cloud/secret_manager"

# Create a Secret Manager client.
client = Google::Cloud::SecretManager.secret_manager_service

# Build the resource name of the secret.
name = client.secret_path project: project_id, secret: secret_id

# Get the current IAM policy.
policy = client.get_iam_policy resource: name

# Add new member to current bindings
policy.bindings << Google::Iam::V1::Binding.new(
  members: [member],
  role:    "roles/secretmanager.secretAccessor"
)

# Update IAM policy
new_policy = client.set_iam_policy resource: name, policy: policy

# Print a success message.
puts "Updated IAM policy for #{secret_id}"

API

Remarque : Contrairement aux autres exemples, ceci remplace l'ensemble de la stratégie IAM.

$ curl "https://secretmanager.googleapis.com/v1/projects/project-id/secrets/secret-id:setIamPolicy" \
    --request "POST" \
    --header "authorization: Bearer $(gcloud auth print-access-token)" \
    --header "content-type: application/json" \
    --data "{\"policy\": {\"bindings\": [{\"members\": [\"member\"], \"role\": \"roles/secretmanager.secretAccessor\"}]}}"

Pour en savoir plus sur l'octroi ou la révocation de l'accès aux secrets, consultez Gérer l'accès aux secrets.

Ajouter des identifiants Docker Hub à votre dépôt distant

Pour mettre à jour votre dépôt distant avec vos identifiants Docker Hub :

Console

  1. Ouvrez la page Dépôts dans la Google Cloud console.

    Ouvrir la page "Dépôts"

  2. Dans la liste des dépôts, sélectionnez le dépôt, puis cliquez sur Modifier le dépôt.

  3. Dans la section Mode d'authentification du dépôt distant, mettez à jour ou ajoutez votre nom d'utilisateur Docker Hub et la version secrète contenant votre jeton d'accès Docker Hub.

Gcloud CLI

Pour mettre à jour votre dépôt distant avec vos identifiants Docker Hub, exécutez la commande suivante :

gcloud artifacts repositories update REPOSITORY \
    --project=PROJECT_ID \
    --location=LOCATION \
    --remote-username=USERNAME \
    --remote-password-secret-version=projects/SECRET_PROJECT_ID/secrets/SECRET_ID/versions/SECRET_VERSION

Remplacez les éléments suivants :

  • REPOSITORY par le nom de votre dépôt distant Artifact Registry ;
  • PROJECT_ID par l'ID de votre Google Cloud projet ;
  • LOCATION par l'emplacement régional ou multirégional location du dépôt. Vous pouvez ignorer cette option si vous définissez une valeur par défaut. Pour afficher la liste des emplacements compatibles, exécutez la commande gcloud artifacts locations list.
  • USERNAME par votre nom d'utilisateur Docker Hub ;
  • SECRET_PROJECT_ID par l'ID du Google Cloud projet dans lequel vous avez créé votre secret ;
  • SECRET_ID par le nom que vous avez donné à votre secret ;
  • SECRET_VERSION par la version secrète dans laquelle vous avez enregistré votre jeton d'accès Docker Hub.

Vos identifiants seront utilisés la prochaine fois que le dépôt distant enverra une requête pour un artefact à partir de la source en amont.

Étape suivante