Abilita una versione del secret disabilitata

Questo argomento illustra come abilitare una versione del secret disabilitata. Quando attivi una una versione del secret disabilitata, puoi accedervi di nuovo.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per abilitare una versione del secret disabilitata, chiedi all'amministratore di concederti Ruolo IAM Secret Manager Secret Manager (roles/secretmanager.secretVersionManager) su un secret. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite la ruoli o altri ruoli predefiniti ruoli.

Abilita una versione del secret disabilitata

Console

  1. Vai alla pagina Secret Manager nella console Google Cloud.

    Vai alla pagina di Secret Manager

  2. Nella pagina Secret Manager, fai clic sul nome di un secret.

  3. Nella tabella Versioni della pagina Dettagli secret, individua una versione del secret a cui accedere.

  4. Nella colonna Azioni, fai clic su Mostra altro.

  5. Fai clic su Attiva nel menu.

  6. Nella finestra di dialogo Abilita versione secret, fai clic sul pulsante Abilita versioni selezionate.

gcloud

Per utilizzare Secret Manager nella riga di comando, devi prima Installa o esegui l'upgrade alla versione 378.0.0 o successive di Google Cloud CLI. In Compute Engine o GKE, devi eseguire l'autenticazione con l'ambito cloud-platform.

$ gcloud secrets versions enable version-id --secret="secret-id"

C#

Per eseguire questo codice, per prima cosa configura un ambiente di sviluppo C# e installare l'SDK Secret Manager C#. In Compute Engine o GKE, devi eseguire l'autenticazione con l'ambito cloud-platform.


using Google.Cloud.SecretManager.V1;

public class EnableSecretVersionSample
{
    public SecretVersion EnableSecretVersion(
      string projectId = "my-project", string secretId = "my-secret", string secretVersionId = "123")
    {
        // Create the client.
        SecretManagerServiceClient client = SecretManagerServiceClient.Create();

        // Build the resource name.
        SecretVersionName secretVersionName = new SecretVersionName(projectId, secretId, secretVersionId);

        // Call the API.
        SecretVersion version = client.EnableSecretVersion(secretVersionName);
        return version;
    }
}

Go

Per eseguire questo codice, devi prima configurare un ambiente di sviluppo Go e installa l'SDK Secret Manager Go. In Compute Engine o GKE, devi eseguire l'autenticazione con l'ambito cloud-platform.

import (
	"context"
	"fmt"

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

// enableSecretVersion enables the given secret version, enabling it to be
// accessed after previously being disabled. Other secrets versions are
// unaffected.
func enableSecretVersion(name string) error {
	// name := "projects/my-project/secrets/my-secret/versions/5"

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

	// Build the request.
	req := &secretmanagerpb.EnableSecretVersionRequest{
		Name: name,
	}

	// Call the API.
	if _, err := client.EnableSecretVersion(ctx, req); err != nil {
		return fmt.Errorf("failed to enable secret version: %w", err)
	}
	return nil
}

Java

Per eseguire questo codice, per prima cosa configura un ambiente di sviluppo Java e installa l'SDK Java di Secret Manager. In Compute Engine o GKE, devi eseguire l'autenticazione con l'ambito cloud-platform.

import com.google.cloud.secretmanager.v1.SecretManagerServiceClient;
import com.google.cloud.secretmanager.v1.SecretVersion;
import com.google.cloud.secretmanager.v1.SecretVersionName;
import java.io.IOException;

public class EnableSecretVersion {

  public static void enableSecretVersion() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String secretId = "your-secret-id";
    String versionId = "your-version-id";
    enableSecretVersion(projectId, secretId, versionId);
  }

  // Enable an existing secret version.
  public static void enableSecretVersion(String projectId, String secretId, String versionId)
      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.
      SecretVersionName secretVersionName = SecretVersionName.of(projectId, secretId, versionId);

      // Enable the secret version.
      SecretVersion version = client.enableSecretVersion(secretVersionName);
      System.out.printf("Enabled secret version %s\n", version.getName());
    }
  }
}

Node.js

Per eseguire questo codice, devi prima configurare un ambiente di sviluppo Node.js e installare l'SDK Node.js di Secret Manager. In Compute Engine o GKE, devi eseguire l'autenticazione con l'ambito cloud-platform.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const name = 'projects/my-project/secrets/my-secret/versions/5';

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

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

async function enableSecretVersion() {
  const [version] = await client.enableSecretVersion({
    name: name,
  });

  console.info(`Enabled ${version.name}`);
}

enableSecretVersion();

PHP

Per eseguire questo codice, scopri innanzitutto come utilizzare PHP su Google Cloud e installa l'SDK PHP di Secret Manager. In Compute Engine o GKE, devi eseguire l'autenticazione con l'ambito cloud-platform.

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

/**
 * @param string $projectId Your Google Cloud Project ID (e.g. 'my-project')
 * @param string $secretId  Your secret ID (e.g. 'my-secret')
 * @param string $versionId Your version ID (e.g. 'latest' or '5');
 */
function enable_secret_version(string $projectId, string $secretId, string $versionId): void
{
    // Create the Secret Manager client.
    $client = new SecretManagerServiceClient();

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

    // Build the request.
    $request = EnableSecretVersionRequest::build($name);

    // Enable the secret version.
    $response = $client->enableSecretVersion($request);

    // Print a success message.
    printf('Enabled secret version: %s', $response->getName());
}

Python

Per eseguire questo codice, configura prima un ambiente di sviluppo Python e installare l'SDK per Python di Secret Manager. In Compute Engine o GKE, devi eseguire l'autenticazione con l'ambito cloud-platform.

def enable_secret_version(
    project_id: str, secret_id: str, version_id: str
) -> secretmanager.EnableSecretVersionRequest:
    """
    Enable the given secret version, enabling it to be accessed after
    previously being disabled. Other secrets versions are unaffected.
    """

    # 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 version
    name = f"projects/{project_id}/secrets/{secret_id}/versions/{version_id}"

    # Disable the secret version.
    response = client.enable_secret_version(request={"name": name})

    print(f"Enabled secret version: {response.name}")

Ruby

Per eseguire questo codice, prima configura un ambiente di sviluppo Ruby e installa l'SDK Ruby di Secret Manager. In Compute Engine o GKE, devi eseguire l'autenticazione con l'ambito cloud-platform.

# project_id = "YOUR-GOOGLE-CLOUD-PROJECT"  # (e.g. "my-project")
# secret_id  = "YOUR-SECRET-ID"             # (e.g. "my-secret")
# version_id = "YOUR-VERSION"               # (e.g. "5" or "latest")

# 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 version.
name = client.secret_version_path(
  project:        project_id,
  secret:         secret_id,
  secret_version: version_id
)

# Enable the secret version.
response = client.enable_secret_version name: name

# Print a success message.
puts "Enabled secret version: #{response.name}"

API

In questi esempi viene utilizzato curl per dimostrare l'utilizzo dell'API. Puoi generare token di accesso con gcloud auth stampa-access-token. In Compute Engine o GKE, devi eseguire l'autenticazione con l'ambito cloud-platform.

$ curl "https://secretmanager.googleapis.com/v1/projects/project-id/secrets/secret-id/versions/version-id:enable" \
    --request "POST" \
    --header "authorization: Bearer $(gcloud auth print-access-token)" \
    --header "content-type: application/json"

Passaggi successivi