Esta página se ha traducido con Cloud Translation API.

Configurar la autenticación de repositorios remotos en el índice de paquetes de Python (PyPI)

En este documento se describe cómo configurar la autenticación en repositorios upstream de Python Package Index (PyPI) para repositorios remotos de Artifact Registry.

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

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 PyPI para repositorios remotos, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos en el proyecto:

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

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 API de PyPI

Inicia sesión en PyPI.
Crea un token de API.

Guardar el token de la API en una versión secreta

Crea un secreto en Secret Manager.
Guarda tu token de la API de PyPI como una versión de secreto.

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

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

Ve a la página Secret Manager.
En la página Secret Manager, marca la casilla situada junto al nombre del secreto.
Si aún no lo has hecho, haz clic en Mostrar panel de información para abrirlo.
En el panel de información, haz clic en Añadir principal.
En el área de texto Nuevos administradores, introduce las direcciones de correo de los miembros que quieras añadir.
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

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, 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 PyPI a tu repositorio remoto

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

Consola

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

Abre la página Repositorios.
En la lista de repositorios, selecciona el repositorio y haz clic en Editar repositorio.
En la sección Remote repository authentication mode (Modo de autenticación de repositorio remoto), actualiza o añade tu nombre de usuario de PYPI __token__ y la versión secreta que contiene tu token de API de PyPI.

CLI de gcloud

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

gcloud artifacts repositories update REPOSITORY \
    --project=PROJECT_ID \
    --location=LOCATION \
    --remote-username=__token__ \
    --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 PyPI.
SECRET_PROJECT_ID por el ID del proyecto 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 API de PyPI.

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

Configurar la autenticación de repositorios remotos en el índice de paquetes de Python (PyPI) Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Roles obligatorios

Crear un token de API de PyPI

Guardar el token de la API en una versión secreta

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

Consola

gcloud

C#

Go

Java

Node.js

PHP

Python

Ruby

API

Añadir credenciales de PyPI a tu repositorio remoto

Consola

CLI de gcloud

Configurar la autenticación de repositorios remotos en el índice de paquetes de Python (PyPI)