Configurar la autenticación del repositorio remoto en Docker Hub

En este documento se describe cómo configurar la autenticación en repositorios upstream de Docker Hub para repositorios remotos de Artifact Registry.

Te recomendamos que te autentiques en Docker Hub aunque solo uses imágenes públicas, ya que así aumentarás el límite de velocidad de descarga. Para obtener más información sobre los límites de velocidad de descarga de Docker Hub, consulta Límite de velocidad de Docker Hub. Los repositorios remotos te permiten añadir tu nombre de usuario de Docker Hub y un token de acceso personal guardado como secreto para autenticarte en Docker Hub.

En este documento se presupone que ya ha creado un repositorio remoto de Docker de Artifact Registry y una cuenta de Docker Hub.

Para obtener más información sobre los repositorios remotos, consulta la descripción general de los repositorios remotos.

Roles obligatorios

Para obtener los permisos que necesitas para configurar la autenticación en Docker Hub para repositorios remotos, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos en el proyecto:

Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

También puedes conseguir los permisos necesarios a través de roles personalizados u otros roles predefinidos.

Crear un token de acceso personal de Docker Hub

  1. Inicia sesión en Docker Hub.
  2. Crea un token de acceso personal con permisos de solo lectura.

  3. Copia el token de acceso.

  4. Guarda el token de acceso en un archivo de texto en tu sistema local o en Cloud Shell.

Guardar tu token de acceso personal en una versión de secreto

  1. Crea un secreto en Secret Manager.
  2. Guarda tu token de acceso personal de Docker Hub como una versión secreta.

Concede acceso a tu secreto a la cuenta de servicio de Artifact Registry

El agente de servicio de Artifact Registry actúa en nombre de Artifact Registry al interactuar con los servicios. Google Cloud Para permitir que el agente de servicio use los secretos almacenados en Secret Manager, debes concederle permiso para ver tu versión del secreto.

El identificador del agente de servicio es:

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

PROJECT-NUMBER es el número de proyecto del proyecto Google Cloud en el que se ejecuta Artifact Registry.

Para asignar el rol Lector de recursos de Secret Manager al agente de servicio de Artifact Registry, sigue estos pasos:

Consola

  1. Ve a la página Secret Manager en la Google Cloud consola.

    Ve a la página Secret Manager.

  2. En la página Secret Manager, marca la casilla situada junto al nombre del secreto.

  3. Si aún no lo has hecho, haz clic en Mostrar panel de información para abrirlo.

  4. En el panel de información, haz clic en Añadir principal.

  5. En el área de texto Nuevos administradores, introduce las direcciones de correo de los miembros que quieras añadir.

  6. En el menú desplegable Selecciona un rol, elige Secret Manager y, a continuación, Permiso para acceder a los recursos de Secret Manager.

gcloud

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

Donde member es un miembro de gestión de identidades y accesos, como un usuario, un grupo o una cuenta de servicio.

C#

Para autenticarte en Artifact Registry, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo 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

Para autenticarte en Artifact Registry, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo 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

Para autenticarte en Artifact Registry, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo 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

Para autenticarte en Artifact Registry, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo 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

Para autenticarte en Artifact Registry, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo 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 = $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

Para autenticarte en Artifact Registry, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo 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

Para autenticarte en Artifact Registry, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo 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

Nota: A diferencia de los otros ejemplos, este reemplaza toda la política de gestión de identidades y accesos.

$ 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\"}]}}"

Para obtener más información sobre cómo conceder o revocar el acceso a secretos, consulta Gestionar el acceso a secretos.

Añadir credenciales de Docker Hub a tu repositorio remoto

Para actualizar tu repositorio remoto con tus credenciales de Docker Hub, sigue estos pasos:

Consola

  1. Abre la página Repositorios en la consola de Google Cloud .

    Abre la página Repositorios.

  2. En la lista de repositorios, selecciona el repositorio y haz clic en Editar repositorio.

  3. En la sección Remote repository authentication mode (Modo de autenticación de repositorio remoto), actualiza o añade tu nombre de usuario de Docker Hub y la versión secreta que contiene tu token de acceso de Docker Hub.

CLI de gcloud

Para actualizar tu repositorio remoto con tus credenciales de Docker Hub, ejecuta el siguiente comando:

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

Haz los cambios siguientes:

  • REPOSITORY por el nombre de tu repositorio remoto de Artifact Registry.
  • PROJECT_ID por el ID de tu proyecto. Google Cloud
  • LOCATION con la ubicación regional o multirregional del repositorio. Puedes omitir esta marca si defines un valor predeterminado. Para ver una lista de las ubicaciones admitidas, ejecuta el comando gcloud artifacts locations list.
  • USERNAME con tu nombre de usuario de Docker Hub.
  • SECRET_PROJECT_ID por el ID del proyectoGoogle Cloud en el que has creado el secreto.
  • SECRET_ID con el nombre que le has dado al secreto.
  • SECRET_VERSION con la versión del secreto en la que has guardado tu token de acceso de Docker Hub.

Tus credenciales se usarán la próxima vez que el repositorio remoto envíe una solicitud de un artefacto desde la fuente upstream.

Siguientes pasos