Crea un secret

Questa pagina descrive come creare un secret. Un secret contiene una o più versioni del secret, oltre a metadati come etichette e criteri di replica. I contenuti effettivi di un secret sono archiviati in una versione del secret.

Prima di iniziare

  1. Abilita l'API Secret Manager.

  2. Configurare l'autenticazione.

    Select the tab for how you plan to use the samples on this page:

    Console

    When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

    gcloud

      In the Google Cloud console, activate Cloud Shell.

      Activate Cloud Shell

      At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

      REST

      Per utilizzare gli esempi di API REST in questa pagina in un ambiente di sviluppo locale, utilizzi le credenziali che fornisci a gcloud CLI.

        After installing the Google Cloud CLI, initialize it by running the following command:

        gcloud init

        If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

      Per saperne di più, consulta la sezione Autenticarsi per l'utilizzo di REST nella documentazione sull'autenticazione di Google Cloud .

      Ruoli obbligatori

      Per ottenere le autorizzazioni necessarie per creare un secret, chiedi all'amministratore di concederti il ruolo IAM Secret Manager Admin (roles/secretmanager.admin) nel progetto, nella cartella o nell'organizzazione. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

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

      Crea un secret

      Puoi creare secret utilizzando la console Google Cloud , Google Cloud CLI, l'API Secret Manager o le librerie client di Secret Manager.

      Console

      1. Nella console Google Cloud , vai alla pagina Secret Manager.

        Vai a Secret Manager

      2. Nella pagina Secret Manager, fai clic su Crea secret.

      3. Nella pagina Crea secret, inserisci un nome per il secret nel campo Nome. Il nome di un secret può contenere lettere maiuscole e minuscole, numeri, trattini e trattini bassi. La lunghezza massima consentita per un nome è 255 caratteri.

      4. Inserisci un valore per il secret (ad esempio, abcd1234). Il valore del secret può essere in qualsiasi formato, ma non deve superare i 64 KiB. Puoi anche caricare un file di testo contenente il valore del secret utilizzando l'opzione Carica file. Questa azione crea automaticamente la versione del secret.

      5. Fai clic su Crea secret.

      gcloud

      Prima di utilizzare i dati dei comandi riportati di seguito, effettua le seguenti sostituzioni:

      • SECRET_ID: l'ID del secret o l'identificatore completo del secret
      • REPLICATION_POLICY: il criterio di replica per il secret, che può essere automatico o gestito dall'utente.

      Esegui questo comando:

      Linux, macOS o Cloud Shell

      gcloud secrets create SECRET_ID \
          --replication-policy="REPLICATION_POLICY"

      Windows (PowerShell)

      gcloud secrets create SECRET_ID `
          --replication-policy="REPLICATION_POLICY"

      Windows (cmd.exe)

      gcloud secrets create SECRET_ID ^
          --replication-policy="REPLICATION_POLICY"

      REST

      Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

      • PROJECT_ID: l'ID progetto Google Cloud
      • SECRET_ID: l'ID del secret o l'identificatore completo del secret
      • REPLICATION_POLICY: il criterio di replica per il secret, che può essere automatico o gestito dall'utente.

      Metodo HTTP e URL:

      POST https://secretmanager.googleapis.com/v1/projects/PROJECT_ID/secrets?secretId=SECRET_ID

      Corpo JSON della richiesta:

      {
        "replication": {
          "REPLICATION_POLICY": {}
        }
      }
      

      Per inviare la richiesta, scegli una di queste opzioni:

      curl

      Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

      curl -X POST \
      -H "Authorization: Bearer $(gcloud auth print-access-token)" \
      -H "Content-Type: application/json; charset=utf-8" \
      -d @request.json \
      "https://secretmanager.googleapis.com/v1/projects/PROJECT_ID/secrets?secretId=SECRET_ID"

      PowerShell

      Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

      $cred = gcloud auth print-access-token
      $headers = @{ "Authorization" = "Bearer $cred" }

      Invoke-WebRequest `
      -Method POST `
      -Headers $headers `
      -ContentType: "application/json; charset=utf-8" `
      -InFile request.json `
      -Uri "https://secretmanager.googleapis.com/v1/projects/PROJECT_ID/secrets?secretId=SECRET_ID" | Select-Object -Expand Content

      Dovresti ricevere una risposta JSON simile alla seguente:

      {
        "name": "projects/PROJECT_ID/secrets/SECRET_ID",
        "createTime": "2024-03-25T08:24:13.153705Z",
        "etag": "\"161477e6071da9\""
      }
      

      C#

      Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo C# e installare l'SDK C# di Secret Manager. Su Compute Engine o GKE, devi eseguire l'autenticazione con l'ambito cloud-platform.

      
      using Google.Api.Gax.ResourceNames;
      using Google.Cloud.SecretManager.V1;
      
      public class CreateSecretSample
      {
          public Secret CreateSecret(
            string projectId = "my-project", string secretId = "my-secret")
          {
              // Create the client.
              SecretManagerServiceClient client = SecretManagerServiceClient.Create();
      
              // Build the parent resource name.
              ProjectName projectName = new ProjectName(projectId);
      
              // Build the secret.
              Secret secret = new Secret
              {
                  Replication = new Replication
                  {
                      Automatic = new Replication.Types.Automatic(),
                  },
              };
      
              // Call the API.
              Secret createdSecret = client.CreateSecret(projectName, secretId, secret);
              return createdSecret;
          }
      }

      Go

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

      import (
      	"context"
      	"fmt"
      	"io"
      
      	secretmanager "cloud.google.com/go/secretmanager/apiv1"
      	"cloud.google.com/go/secretmanager/apiv1/secretmanagerpb"
      )
      
      // createSecret creates a new secret with the given name. A secret is a logical
      // wrapper around a collection of secret versions. Secret versions hold the
      // actual secret material.
      func createSecret(w io.Writer, parent, id string) error {
      	// parent := "projects/my-project"
      	// id := "my-secret"
      
      	// 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.CreateSecretRequest{
      		Parent:   parent,
      		SecretId: id,
      		Secret: &secretmanagerpb.Secret{
      			Replication: &secretmanagerpb.Replication{
      				Replication: &secretmanagerpb.Replication_Automatic_{
      					Automatic: &secretmanagerpb.Replication_Automatic{},
      				},
      			},
      		},
      	}
      
      	// Call the API.
      	result, err := client.CreateSecret(ctx, req)
      	if err != nil {
      		return fmt.Errorf("failed to create secret: %w", err)
      	}
      	fmt.Fprintf(w, "Created secret: %s\n", result.Name)
      	return nil
      }
      

      Java

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

      import com.google.cloud.secretmanager.v1.ProjectName;
      import com.google.cloud.secretmanager.v1.Replication;
      import com.google.cloud.secretmanager.v1.Secret;
      import com.google.cloud.secretmanager.v1.SecretManagerServiceClient;
      import com.google.protobuf.Duration;
      import java.io.IOException;
      
      public class CreateSecret {
      
        public static void createSecret() throws IOException {
          // TODO(developer): Replace these variables before running the sample.
          String projectId = "your-project-id";
          String secretId = "your-secret-id";
          createSecret(projectId, secretId);
        }
      
        // Create a new secret with automatic replication.
        public static void createSecret(String projectId, String secretId) throws IOException {
          // Initialize the 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 parent name from the project.
            ProjectName projectName = ProjectName.of(projectId);
      
            // Optionally set a TTL for the secret. This demonstrates how to configure
            // a secret to be automatically deleted after a certain period. The TTL is
            // specified in seconds (e.g., 900 for 15 minutes). This can be useful
            // for managing sensitive data and reducing storage costs.
            Duration ttl = Duration.newBuilder().setSeconds(900).build();
      
            // Build the secret to create.
            Secret secret =
                Secret.newBuilder()
                    .setReplication(
                        Replication.newBuilder()
                            .setAutomatic(Replication.Automatic.newBuilder().build())
                            .build())
                    .setTtl(ttl)
                    .build();
      
            // Create the secret.
            Secret createdSecret = client.createSecret(projectName, secretId, secret);
            System.out.printf("Created secret %s\n", createdSecret.getName());
          }
        }
      }

      Node.js

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

      /**
       * TODO(developer): Uncomment these variables before running the sample.
       */
      // const parent = 'projects/my-project';
      // const secretId = 'my-secret';
      // const ttl = undefined // Optional: Specify TTL in seconds (e.g., '900s' for 15 minutes).
      
      // Imports the Secret Manager library
      const {SecretManagerServiceClient} = require('@google-cloud/secret-manager');
      
      // Instantiates a client
      const client = new SecretManagerServiceClient();
      
      async function createSecret() {
        const secretConfig = {
          replication: {
            automatic: {},
          },
        };
      
        // Add TTL to the secret configuration if provided
        if (ttl) {
          secretConfig.ttl = {
            seconds: parseInt(ttl.replace('s', ''), 10),
          };
          console.log(`Secret TTL set to ${ttl}`);
        }
      
        const [secret] = await client.createSecret({
          parent: parent,
          secretId: secretId,
          secret: secretConfig,
        });
      
        console.log(`Created secret ${secret.name}`);
      }
      
      createSecret();

      PHP

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

      // Import the Secret Manager client library.
      use Google\Cloud\SecretManager\V1\CreateSecretRequest;
      use Google\Cloud\SecretManager\V1\Replication;
      use Google\Cloud\SecretManager\V1\Replication\Automatic;
      use Google\Cloud\SecretManager\V1\Secret;
      use Google\Cloud\SecretManager\V1\Client\SecretManagerServiceClient;
      
      /**
       * @param string $projectId Your Google Cloud Project ID (e.g. 'my-project')
       * @param string $secretId  Your secret ID (e.g. 'my-secret')
       */
      function create_secret(string $projectId, string $secretId): void
      {
          // Create the Secret Manager client.
          $client = new SecretManagerServiceClient();
      
          // Build the resource name of the parent project.
          $parent = $client->projectName($projectId);
      
          $secret = new Secret([
              'replication' => new Replication([
                  'automatic' => new Automatic(),
              ]),
          ]);
      
          // Build the request.
          $request = CreateSecretRequest::build($parent, $secretId, $secret);
      
          // Create the secret.
          $newSecret = $client->createSecret($request);
      
          // Print the new secret name.
          printf('Created secret: %s', $newSecret->getName());
      }

      Python

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

      # Import the Secret Manager client library.
      from google.cloud import secretmanager
      
      
      def create_secret(
          project_id: str, secret_id: str, ttl: Optional[str] = None
      ) -> secretmanager.Secret:
          """
          Create a new secret with the given name. A secret is a logical wrapper
          around a collection of secret versions. Secret versions hold the actual
          secret material.
      
           Args:
              project_id (str): The project ID where the secret is to be created.
              secret_id (str): The ID to assign to the new secret. This ID must be unique within the project.
              ttl (Optional[str]): An optional string that specifies the secret's time-to-live in seconds with
                                   format (e.g., "900s" for 15 minutes). If specified, the secret
                                   versions will be automatically deleted upon reaching the end of the TTL period.
      
          Returns:
              secretmanager.Secret: An object representing the newly created secret, containing details like the
                                    secret's name, replication settings, and optionally its TTL.
      
          Example:
              # Create a secret with automatic replication and no TTL
              new_secret = create_secret("my-project", "my-new-secret")
      
              # Create a secret with a TTL of 30 days
              new_secret_with_ttl = create_secret("my-project", "my-timed-secret", "7776000s")
          """
      
          # Create the Secret Manager client.
          client = secretmanager.SecretManagerServiceClient()
      
          # Build the resource name of the parent project.
          parent = f"projects/{project_id}"
      
          # Create the secret.
          response = client.create_secret(
              request={
                  "parent": parent,
                  "secret_id": secret_id,
                  "secret": {"replication": {"automatic": {}}, "ttl": ttl},
              }
          )
      
          # Print the new secret name.
          print(f"Created secret: {response.name}")

      Ruby

      Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo Ruby e installare l'SDK Ruby di Secret Manager. Su 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")
      
      # 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 parent project.
      parent = client.project_path project: project_id
      
      # Create the secret.
      secret = client.create_secret(
        parent:    parent,
        secret_id: secret_id,
        secret:    {
          replication: {
            automatic: {}
          }
        }
      )
      
      # Print the new secret name.
      puts "Created secret: #{secret.name}"

      Per selezionare il criterio di replica giusto per il tuo secret, consulta Scegliere un criterio di replica.

      Aggiungi una versione del secret

      Secret Manager esegue automaticamente il controllo delle versioni dei dati secret utilizzando le versioni dei secret. Le operazioni sulle chiavi, ad esempio accesso, eliminazione, disabilitazione e abilitazione, vengono applicate a versioni specifiche del secret. Con Secret Manager, puoi associare i secret a versioni specifiche come 42 o ad alias dinamici come latest. Per saperne di più, vedi Aggiungere una versione del secret.

      Accedere a una versione del secret

      Per accedere ai dati del secret da una particolare versione del secret per l'autenticazione riuscita, vedi Accedere a una versione del secret.

      Passaggi successivi