Configura la autenticación en flujos ascendentes de repositorios remotos

En este documento, se describe cómo autenticar las fuentes ascendentes de tus repositorios remotos de Artifact Registry.

En este documento, se supone que ya creaste un repositorio remoto de Artifact Registry y que tienes una cuenta con la fuente externa.

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

Funciones obligatorias

Si quieres obtener los permisos que necesitas para configurar la autenticación en fuentes ascendentes de repositorios remotos, pídele a tu administrador que te otorgue los siguientes roles de IAM en el proyecto:

Administrador de Artifact Registry (roles/artifactregistry.admin)
Administrador de Secret Manager (roles/secretmanager.admin)

Si quieres obtener más información para otorgar roles, consulta Administra el acceso.

Es posible que también puedas obtener los permisos necesarios a través de los roles personalizados o de otros roles predefinidos.

Fuentes ascendentes predeterminadas

Para configurar la autenticación de las fuentes ascendentes predeterminadas, consulta la guía correspondiente de cada una de las siguientes fuentes ascendentes:

Fuentes ascendentes definidas por el usuario

Para configurar la autenticación de las fuentes ascendentes definidas por el usuario, completa los siguientes pasos.

Guarda tu token de acceso en un secreto

Crear un token de acceso en el registro privado
Crea un Secret en Secret Manager.
Guarda tu token de acceso personal como una versión secreta.

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

El agente de servicio de Artifact Registry es una cuenta de servicio administrada por Google que actúa en nombre de Artifact Registry cuando interactúa con los servicios de Google Cloud. Si quieres permitir que el agente de servicio use los secretos almacenados en Secret Manager, debes otorgarle permiso para ver tu versión del secreto.

El identificador del agente de servicio es el siguiente:

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

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

Para otorgar al agente de servicio de Artifact Registry la función de Descriptor de acceso a secretos de Secret Manager, haz lo siguiente:

Console

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

Ir a la página Secret Manager
En la página Secret Manager, haz clic en la casilla de verificación junto al nombre del secreto.
Si aún no está abierto, haz clic en Mostrar panel de información para abrir el panel.
En el panel de información, haz clic en Agregar principal.
En el área de texto Principales nuevas, ingresa las direcciones de correo electrónico de los miembros que deseas agregar.
En el menú desplegable Selecciona una función, selecciona Secret Manager y, luego, Administrador y descriptor de acceso a Secretos.

gcloud

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

En el ejemplo anterior, member es un miembro de IAM, como un usuario, un grupo o una cuenta de servicio.

C#

Para autenticarte en Artifact Registry, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para 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

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

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

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

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

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

# 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, esto reemplaza toda la política de 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\"}]}}"

Si quieres obtener más información para otorgar o revocar el acceso a los secretos, consulta Administra el acceso a los secretos.

Agrega credenciales upstream a tu repositorio remoto

Para actualizar tu repositorio remoto con tus credenciales de origen ascendentes, haz lo siguiente:

Console

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

Abrir la página Repositorios
En la lista de repositorios, selecciona el repositorio y haz clic en Editar repositorio.
En la sección Modo de autenticación del repositorio remoto, actualiza o agrega tu nombre de usuario de origen ascendente y el secreto que contiene tu token de acceso.

gcloud CLI

Para actualizar el repositorio remoto con tus credenciales de origen ascendentes, 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

Reemplaza lo siguiente:

REPOSITORY por el nombre de tu repositorio remoto de Artifact Registry
PROJECT_ID por el ID del proyecto de Google Cloud.
LOCATION por la ubicación regional o multirregional para el repositorio Puedes omitir esta marca si estableces un valor predeterminado. Para ver una lista de ubicaciones admitidas, ejecuta el comando gcloud artifacts locations list.
USERNAME por tu nombre de usuario de origen ascendente
SECRET_PROJECT_ID por el ID del proyecto en el que creaste tu secreto
SECRET_ID por el nombre que le asignaste a tu secreto
SECRET_VERSION por la versión del Secret en la que guardaste tu token de acceso.

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

¿Qué sigue?

Crea políticas de limpieza para limpiar los artefactos innecesarios.