

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Impostazione dell'autenticazione con token al portatore

**Nota**  
Questa pagina riguarda l'autenticazione con token al portatore per CloudWatch Registri. Per CloudWatch Autenticazione con token al portatore di metriche, vedi [Impostazione dell'autenticazione con token al portatore per Metrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-OTLP-MetricsBearerTokenAuth.html) nel *CloudWatch Guida per l'utente*. Per l'autenticazione con token Traces Bearer, vedi [Impostazione dell'autenticazione con token al portatore per le tracce](https://docs.aws.amazon.com/xray/latest/devguide/xray-opentelemetry-bearer-token.html) nel *X-Ray Guida per gli sviluppatori*. Ogni servizio richiede una propria chiave API.

Prima di poter inviare i log utilizzando l'autenticazione con token al portatore con uno qualsiasi degli endpoint di importazione HTTP, devi:
+ Crea un utente IAM con CloudWatch Registra le autorizzazioni
+ Genera credenziali specifiche del servizio (token al portatore)
+ Crea un gruppo di log e un flusso di log
+ Abilita l'autenticazione con token al portatore sul gruppo di log

**Importante**  
Ti consigliamo di utilizzare l'autenticazione SigV4 con credenziali a breve termine per tutti i carichi di lavoro per cui è possibile farlo. SigV4 offre la postura di sicurezza più solida. Limita l'uso delle chiavi API (token al portatore) agli scenari in cui l'autenticazione basata su credenziali a breve termine non è fattibile. Quando sei pronto per l'incorporazione CloudWatch Accede alle applicazioni con requisiti di sicurezza più elevati, è necessario passare a credenziali a breve termine. Per ulteriori informazioni, consulta [Alternative alle chiavi di accesso a lungo termine](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-workloads-use-roles) nella *Guida per l'utente di IAM*.

## Opzione 1: avvio rapido utilizzando AWS console
<a name="CWL_HTTP_Endpoints_Console_Setup"></a>

Il AWS La console di gestione fornisce un flusso di lavoro semplificato per generare chiavi API per l'accesso agli endpoint HTTP.

**Per configurare l'accesso agli endpoint HTTP utilizzando la console**

1. Accedere al AWS Console di gestione.

1. Passa a **CloudWatch** > **Impostazioni** > **Registri**.

1. Nella sezione Chiavi API, scegli **Genera chiave API**.

1. Per **Scadenza della chiave API**, esegui una delle seguenti operazioni:
   + Seleziona una durata di scadenza della chiave API di **1**, **5**, **30**, **90** o **365** giorni.
   + Scegli **Durata personalizzata** per specificare una data di scadenza della chiave API personalizzata.
   + Seleziona **Non scade mai** (scelta non consigliata)

1. Scegli **Genera chiave API**.

   La console esegue automaticamente le seguenti operazioni:
   + Crea un nuovo utente IAM con autorizzazioni appropriate
   + Allega il [CloudWatchLogsAPIKeyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchLogsAPIKeyAccess.html) politica gestita (include `logs:PutLogEvents` e `logs:CallWithBearerToken` autorizzazioni)
   + Genera credenziali specifiche del servizio (chiave API)

1. Copia e salva in modo sicuro le credenziali visualizzate:
   + **ID della chiave API** (Service-specific ID delle credenziali)
   + **Chiave API segreta** (token bearer)
**Importante**  
Salva immediatamente l’API Key Secret. Non può essere recuperata più tardi. Se lo perdi, dovrai generare una nuova chiave API.

1. Crea il gruppo di log e lo stream di log in cui verranno archiviati i tuoi log:

   ```bash
   # Create the log group
   aws logs create-log-group \
       --log-group-name /aws/hlc-logs/my-application \
       --region us-east-1
   
   # Create the log stream
   aws logs create-log-stream \
       --log-group-name /aws/hlc-logs/my-application \
       --log-stream-name application-stream-001 \
       --region us-east-1
   ```

1. Abilita l'autenticazione con token al portatore sul gruppo di log:

   ```bash
   aws logs put-bearer-token-authentication \
       --log-group-identifier /aws/hlc-logs/my-application \
       --bearer-token-authentication-enabled \
       --region us-east-1
   ```

   Verifica la configurazione:

   ```bash
   aws logs describe-log-groups \
       --log-group-name-prefix /aws/hlc-logs/my-application \
       --region us-east-1
   ```

**Autorizzazioni incluse:** L'utente IAM creato automaticamente avrà le seguenti autorizzazioni:
+ `logs:PutLogEvents` — Invia eventi di registro a CloudWatch Registri
+ `logs:CallWithBearerToken` — Autenticazione tramite token al portatore
+ `kms:Describe*`, `kms:GenerateDataKey*`, `kms:Decrypt` — Accesso KMS-encrypted gruppi di log (con condizioni limitate al servizio di log)

## Opzione 2: configurazione manuale
<a name="CWL_HTTP_Endpoints_Manual_Setup"></a>

Se preferisci un maggiore controllo sulla configurazione IAM o hai bisogno di personalizzare le autorizzazioni, puoi configurare manualmente l'accesso all'endpoint HTTP.

### Fase 1: Creare un utente IAM
<a name="CWL_HTTP_Endpoints_Manual_Step1"></a>

Crea un utente IAM che verrà utilizzato per l'inserimento dei log:

1. Accedi al AWS Console di gestione e accedi a IAM.

1. Nel riquadro di navigazione a sinistra, seleziona **Users (Utenti)**.

1. Selezionare **Create user (Crea utente)**.

1. Immetti un nome utente (ad esempio, `cloudwatch-logs-hlc-user`).

1. Scegli **Avanti**.

1. Collega una delle seguenti policy IAM:

   **Opzione A: utilizza la policy gestita (consigliata)**

   Allega il [CloudWatchLogsAPIKeyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchLogsAPIKeyAccess.html) politica gestita.

   **Opzione B: crea una policy personalizzata**

   Crea e collega la seguente policy IAM:

   ```JSON
   {
       "Version": "2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "LogsAPIs",
               "Effect": "Allow",
               "Action": [
                   "logs:CallWithBearerToken",
                   "logs:PutLogEvents"
               ],
               "Resource": "*"
           },
           {
               "Sid": "KMSAPIs",
               "Effect": "Allow",
               "Action": [
                   "kms:Describe*",
                   "kms:GenerateDataKey*",
                   "kms:Decrypt"
               ],
               "Condition": {
                   "StringEquals": {
                       "kms:ViaService": [
                           "logs.*.amazonaws.com"
                       ]
                   }
               },
               "Resource": "arn:aws:kms:*:*:key/*"
           }
       ]
   }
   ```

1. Scegli **Prossimo** e poi **Crea utente**.

**Nota**  
Le autorizzazioni KMS sono necessarie se si prevede di inviare i log a KMS-encrypted gruppi di log. La condizione limita l'accesso KMS alle sole chiavi utilizzate tramite CloudWatch Servizio di log.

### Passaggio 2: generare credenziali specifiche del servizio (chiave API)
<a name="CWL_HTTP_Endpoints_Manual_Step2"></a>

Genera il CloudWatch Registra la chiave API utilizzando [CreateServiceSpecificCredential](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateServiceSpecificCredential.html) API. Puoi anche usare [credenziale specifica per il servizio](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-service-specific-credential.html) Comando CLI. Per l'età delle credenziali, puoi specificare un valore compreso tra 1 e 36.600 giorni. Se non specifici l’età delle credenziali, la chiave API non scadrà.

Per generare una chiave API con una scadenza di 30 giorni:

```bash
aws iam create-service-specific-credential \
    --user-name cloudwatch-logs-hlc-user \
    --service-name logs.amazonaws.com \
    --credential-age-days 30
```

La risposta è [ServiceSpecificCredential](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ServiceSpecificCredential.html) oggetto. Il `ServiceCredentialSecret` il valore è tuo CloudWatch Registra la chiave API (token al portatore).

**Importante**  
Archivia il valore `ServiceCredentialSecret` in modo sicuro, poiché non potrai recuperarlo in un secondo momento. Se la perdi, dovrai generare una nuova chiave API.

### Passaggio 3: creare un gruppo di log e un flusso di log
<a name="CWL_HTTP_Endpoints_Manual_Step3"></a>

Crea il gruppo di log e lo stream di log in cui verranno archiviati i tuoi log:

```bash
# Create the log group
aws logs create-log-group \
    --log-group-name /aws/hlc-logs/my-application \
    --region us-east-1

# Create the log stream
aws logs create-log-stream \
    --log-group-name /aws/hlc-logs/my-application \
    --log-stream-name application-stream-001 \
    --region us-east-1
```

### Passaggio 4: abilita l'autenticazione con token al portatore
<a name="CWL_HTTP_Endpoints_Manual_Step4"></a>

Abilita l'autenticazione con token al portatore nel gruppo di log:

```bash
aws logs put-bearer-token-authentication \
    --log-group-identifier /aws/hlc-logs/my-application \
    --bearer-token-authentication-enabled \
    --region us-east-1
```

Verifica la configurazione:

```bash
aws logs describe-log-groups \
    --log-group-name-prefix /aws/hlc-logs/my-application \
    --region us-east-1
```

## Controlla le autorizzazioni per la generazione e l'utilizzo CloudWatch Registra le chiavi API
<a name="CWL_HTTP_Endpoints_API_Key_Permissions"></a>

La generazione e l'utilizzo di CloudWatch Le chiavi API di Logs sono controllate da azioni e chiavi di condizione in entrambi CloudWatch Log e servizi IAM.

### Controllo della generazione di CloudWatch Registra le chiavi API
<a name="CWL_HTTP_Endpoints_Control_Generation"></a>

Le [sono:CreateServiceSpecificCredential](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsidentityandaccessmanagementiam.html#awsidentityandaccessmanagementiam-actions-as-permissions) action controlla la generazione di una chiave specifica del servizio (ad esempio CloudWatch Registra la chiave API). È possibile questa azione agli utenti IAM come una risorsa per limitare gli utenti per cui è possibile generare una chiave.

Per imporre condizioni all’autorizzazione per l’azione `iam:CreateServiceSpecificCredential`, è possibile utilizzare le chiavi di condizione seguenti:
+ [Sono:ServiceSpecificCredentialAgeDays](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#ck_ServiceSpecificCredentialAgeDays) — Consente di specificare, nella condizione, l'ora di scadenza della chiave in giorni. Ad esempio, si può utilizzare questa chiave di condizione per consentire solo la creazione di chiavi API che scadono entro 90 giorni.
+ [sono:ServiceSpecificCredentialServiceName](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#ck_ServiceSpecificCredentialAgeDays) — Consente di specificare, nella condizione, il nome di un servizio. Ad esempio, è possibile utilizzare questa chiave di condizione per consentire solo la creazione di chiavi API per CloudWatch Log e non altri servizi.

### Controllo dell'uso di CloudWatch Registra le chiavi API
<a name="CWL_HTTP_Endpoints_Control_Usage"></a>

Le `logs:CallWithBearerToken` l'azione controlla l'uso di a CloudWatch Registra la chiave API. Per impedire l'utilizzo di un'identità CloudWatch Registra le chiavi API, allega una policy che nega `logs:CallWithBearerToken` azione sull'utente IAM associato alla chiave.

### Policy di esempio
<a name="CWL_HTTP_Endpoints_Permission_Examples"></a>

#### Impedire la generazione e l'utilizzo di un'identità CloudWatch Registra le chiavi API
<a name="CWL_HTTP_Endpoints_Deny_Generation_And_Use"></a>

```JSON
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "DenyCWLAPIKeys",
            "Effect": "Deny",
            "Action": [
                "iam:CreateServiceSpecificCredential",
                "logs:CallWithBearerToken"
            ],
            "Resource": "*"
        }
    ]
}
```

**avvertimento**  
Questa politica impedirà la creazione di credenziali per tutti AWS servizi che supportano la creazione di credenziali specifiche del servizio. Per ulteriori informazioni, vedere [Service-specific credenziali per gli utenti IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_service-specific-creds.html).

#### Impedire l'utilizzo di un'identità CloudWatch Registra le chiavi API
<a name="CWL_HTTP_Endpoints_Deny_Use"></a>

```JSON
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Deny",
            "Action": "logs:CallWithBearerToken",
            "Resource": "*"
        }
    ]
}
```

#### Consenti la creazione di CloudWatch Registra le chiavi solo se scadono entro 90 giorni
<a name="CWL_HTTP_Endpoints_Allow_Expire_90"></a>

```JSON
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "iam:CreateServiceSpecificCredential",
            "Resource": "arn:aws:iam::123456789012:user/username",
            "Condition": {
                "StringEquals": {
                    "iam:ServiceSpecificCredentialServiceName": "logs.amazonaws.com"
                },
                "NumericLessThanEquals": {
                    "iam:ServiceSpecificCredentialAgeDays": "90"
                }
            }
        }
    ]
}
```

## Rotazione delle chiavi API
<a name="CWL_HTTP_Endpoints_Rotating_Keys"></a>

La rotazione regolare delle chiavi API riduce il rischio di accessi non autorizzati. Ti consigliamo di stabilire un programma di rotazione in linea con le politiche di sicurezza della tua organizzazione.

### Processo di rotazione
<a name="CWL_HTTP_Endpoints_Rotation_Process"></a>

Per ruotare una chiave API senza interrompere la consegna dei log, segui questa procedura:

1. Crea una nuova credenziale (secondaria) per l'utente IAM:

   ```bash
   aws iam create-service-specific-credential \
       --user-name cloudwatch-logs-hlc-user \
       --service-name logs.amazonaws.com \
       --credential-age-days 90
   ```

1. (Facoltativo) Archivia la nuova credenziale in AWS Secrets Manager per un recupero sicuro e una rotazione automatica.

1. Importa la nuova credenziale nel portale del fornitore o aggiorna la configurazione dell'applicazione per utilizzare la nuova chiave API.

1. Imposta la credenziale originale su inattiva:

   ```bash
   aws iam update-service-specific-credential \
       --user-name cloudwatch-logs-hlc-user \
       --service-specific-credential-id ACCA1234EXAMPLE1234 \
       --status Inactive
   ```

1. Verifica che la consegna dei log non sia influenzata monitorando il `IncomingBytes` metrica per il tuo gruppo di log in CloudWatch. Per ulteriori informazioni, vedere [Monitoraggio con CloudWatch metriche](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Monitoring-CloudWatch-Metrics.html).

1. Dopo aver confermato l'avvenuta consegna con la nuova chiave, elimina la credenziale precedente:

   ```bash
   aws iam delete-service-specific-credential \
       --service-specific-credential-id ACCA1234EXAMPLE1234
   ```

### Monitoraggio della scadenza delle chiavi
<a name="CWL_HTTP_Endpoints_Monitor_Expiration"></a>

Per verificare la data di creazione e lo stato delle chiavi API esistenti, usa il comando [list-service-specific-credentials](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/list-service-specific-credentials.html):

```bash
aws iam list-service-specific-credentials \
    --user-name cloudwatch-logs-hlc-user \
    --service-name logs.amazonaws.com
```

La risposta include `CreateDate` e `Status` per ogni credenziale. Utilizza queste informazioni per identificare le chiavi che stanno per scadere o che sono state attive più a lungo di quanto consentito dalla policy di rotazione.

## Risposta a una chiave API compromessa
<a name="CWL_HTTP_Endpoints_Compromised_Keys"></a>

Se sospetti che una chiave API sia stata compromessa, procedi immediatamente come segue:

1. **Disattiva immediatamente la chiave** per evitare ulteriori utilizzi non autorizzati:

   ```bash
   aws iam update-service-specific-credential \
       --user-name cloudwatch-logs-hlc-user \
       --service-specific-credential-id ACCA1234EXAMPLE1234 \
       --status Inactive
   ```

1. **Recensione CloudTrail registri** per determinare l'ambito dell'accesso non autorizzato. Consulta [Registrazione dell'utilizzo della chiave API con CloudTrail](#CWL_HTTP_Endpoints_CloudTrail_Logging) per scoprire come abilitare il controllo dell’utilizzo delle chiavi API.

1. **Crea una chiave sostitutiva** seguendo il processo di rotazione descritto in [Processo di rotazione](#CWL_HTTP_Endpoints_Rotation_Process).

1. **Elimina la chiave compromessa** dopo aver effettuato la sostituzione:

   ```bash
   aws iam delete-service-specific-credential \
       --service-specific-credential-id ACCA1234EXAMPLE1234
   ```

1. **Allega una policy di rifiuto** se devi bloccare immediatamente l'accesso a tutti i token bearer per l'utente IAM durante le indagini:

   ```JSON
   {
       "Version": "2012-10-17",		 	 	 
       "Statement": {
           "Effect": "Deny",
           "Action": "logs:CallWithBearerToken",
           "Resource": "*"
       }
   }
   ```

**Nota**  
Per eseguire queste azioni tramite l'API, è necessario autenticarsi con AWS credenziali e non con un CloudWatch Registra la chiave API.

È anche possibile utilizzare le seguenti operazioni API IAM per gestire le chiavi compromesse:
+ [ResetServiceSpecificCredential](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ResetServiceSpecificCredential.html) — Reimposta la chiave per generare una nuova password senza eliminare la credenziale. La chiave non deve essere ancora scaduta.

## Best practice di sicurezza per le chiavi API
<a name="CWL_HTTP_Endpoints_Security_Best_Practices"></a>

Segui queste best practice per proteggere i tuoi CloudWatch Registra le chiavi API:
+ **Non incorporare mai le chiavi API nel codice sorgente.** Non codificate le chiavi API nel codice dell'applicazione né trasferitele nei sistemi di controllo della versione. Se una chiave viene salvata accidentalmente in un archivio pubblico, AWS la scansione automatica potrebbe segnalarla ed è necessario ruotare immediatamente la chiave.
+ **Utilizza un secrets manager.** Memorizza le chiavi API in [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) o una soluzione equivalente per la gestione dei segreti. Ciò consente il controllo centralizzato degli accessi, la registrazione degli audit e la rotazione automatizzata.
+ **Imposta una scadenza per tutte le chiavi.** Specifica sempre un valore `--credential-age-days` quando crei le chiavi API. Per imporre una durata massima delle chiavi in tutta l’organizzazione, utilizza la chiave di condizione IAM `iam:ServiceSpecificCredentialAgeDays`. Per un esempio, consulta [Consenti la creazione di CloudWatch Registra le chiavi solo se scadono entro 90 giorni](#CWL_HTTP_Endpoints_Allow_Expire_90).
+ **Applica le autorizzazioni con privilegio minimo.** Limita le autorizzazioni dell'utente IAM solo ai gruppi di log e alle azioni richieste. Usa il managed [CloudWatchLogsAPIKeyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchLogsAPIKeyAccess.html) policy come punto di partenza e limitala ulteriormente se necessario.
+ **Abilita CloudTrail registrazione.** Controlla l'utilizzo delle chiavi API abilitando CloudTrail eventi di dati per `AWS::Logs::LogGroupAuthorization`. Consulta [Registrazione dell'utilizzo della chiave API con CloudTrail](#CWL_HTTP_Endpoints_CloudTrail_Logging).
+ **Monitora con IAM Access Analyzer.** Utilizza [IAM Access Analyzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html) per identificare le credenziali non utilizzate e le policy eccessivamente permissive associate agli utenti IAM della tua chiave API.
+ **Ruota le chiavi regolarmente.** Stabilisci un programma di rotazione e segui la procedura descritta in [Rotazione delle chiavi API](#CWL_HTTP_Endpoints_Rotating_Keys).

## Registrazione dell'utilizzo della chiave API con CloudTrail
<a name="CWL_HTTP_Endpoints_CloudTrail_Logging"></a>

Puoi usare AWS CloudTrail per registrare eventi relativi ai dati per CloudWatch Registra l'utilizzo delle chiavi API. CloudWatch Registra le emissioni `AWS::Logs::LogGroupAuthorization` eventi di dati per `CallWithBearerToken` chiamate, che consentono di verificare quando e come le chiavi API vengono utilizzate per inviare i log.

Per abilitare CloudTrail registrazione per CloudWatch Registra l'utilizzo della chiave API:

**Nota**  
Il bucket S3 specificato per il percorso deve avere una policy del bucket che consenta CloudTrail per scrivere file di registro su di esso. Per ulteriori informazioni, vedere [Policy sui bucket di Amazon S3 per CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/create-s3-bucket-policy-for-cloudtrail.html).

1. Creazione di un trail:

   ```bash
   aws cloudtrail create-trail \
       --name cloudwatch-logs-api-key-audit \
       --s3-bucket-name my-cloudtrail-bucket \
       --region us-east-1
   ```

1. Configura selettori di eventi avanzati da catturare CloudWatch Registra gli eventi di autorizzazione dei gruppi:

   ```bash
   aws cloudtrail put-event-selectors \
       --region us-east-1 \
       --trail-name cloudwatch-logs-api-key-audit \
       --advanced-event-selectors '[{
           "Name": "CloudWatch Logs API key authorization events",
           "FieldSelectors": [
               { "Field": "eventCategory", "Equals": ["Data"] },
               { "Field": "resources.type", "Equals": ["AWS::Logs::LogGroupAuthorization"] }
           ]
       }]'
   ```

1. Avvia la registrazione del trail:

   ```bash
   aws cloudtrail start-logging \
       --name cloudwatch-logs-api-key-audit \
       --region us-east-1
   ```