Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# AWSFournisseur d'identifiants de charge de travail
<a name="acm-certificate-automation"></a>

Le fournisseur d'informations d'identification de AWS charge de travail automatise l'utilisation des certificats TLS [publics](https://docs.aws.amazon.com/acm/latest/userguide/acm-exportable-certificates.html) et [privés](https://docs.aws.amazon.com/acm/latest/userguide/export-private.html) exportés depuis ACM. Le fournisseur récupère régulièrement les certificats et leurs clés privées, les écrit dans des chemins configurés et exécute éventuellement une commande pour recharger les services dépendants tels que les serveurs Web.

Vous pouvez utiliser le fournisseur d'informations d'identification de charge de travail dans les environnements informatiques suivants :
+ Amazon Elastic Compute Cloud (Amazon EC2)
+ On-premises serveurs avec AWS informations d'identification

Le fournisseur d'informations d'identification de charge de travail utilise l'hypothèse du rôle IAM pour récupérer les certificats. Il s'exécute nativement en tant que service système sous Linux et Windows sous un utilisateur dédié à faibles privilèges et écrit des fichiers de certificat avec des autorisations restreintes.

**Important**  
Seuls les certificats exportables peuvent être utilisés auprès de ce fournisseur. Pour plus d'informations, reportez-vous à [AWS Certificate Manager certificats publics exportables](acm-exportable-certificates.md) la section [Exportation d'un certificat privé](https://docs.aws.amazon.com/acm/latest/userguide/export-private.html).

Le fournisseur d'informations d'identification de AWS charge de travail est open source. Pour le code source et les contributions, consultez le [GitHub référentiel](https://github.com/aws/aws-workload-credentials-provider).

## Comment fonctionne l'automatisation des certificats
<a name="acm-cert-automation-refresh"></a>

Le fournisseur utilise un planificateur qui actualise chaque certificat configuré à intervalles réguliers :
+ L'intervalle de rafraîchissement est de 24 heures.
+ À chaque cycle, le fournisseur exporte le certificat, le compare aux fichiers sur le disque et écrit de nouveaux fichiers uniquement si le contenu a changé.
+ Lorsque les fichiers de certificats sont mis à jour, le fichier configuré `refresh_command` s'exécute (par exemple, pour recharger NGINX ou Apache).
+ Si le contenu du certificat n'a pas changé, la commande d'actualisation est ignorée.

Le fournisseur effectue une actualisation initiale à chaque démarrage du système et peu de temps après le démarrage du service, avec une légère instabilité aléatoire pour éviter les appels d'API synchronisés lorsque plusieurs fournisseurs démarrent simultanément sur le parc.

Le fournisseur prend également en charge le rechargement dynamique de la configuration, ce qui vous permet d'ajouter, de supprimer ou de modifier des certificats sans les réinstaller. Pour de plus amples informations, veuillez consulter [Rechargement dynamique de la configuration](#acm-cert-automation-reload).

## Conditions préalables
<a name="acm-cert-automation-prereqs"></a>

Avant d'installer le fournisseur, assurez-vous que vous disposez des éléments suivants :
+ Une instance Linux avec systemd (Amazon Linux 2023, Ubuntu 20.04\+ ou RHEL 8\+)
+ Ou une instance Windows exécutant Windows Server 2016 ou version ultérieure avec PowerShell 5.1 ou version ultérieure
+ Accès administrateur pour exécuter le programme d'installation
+ Un certificat exportable dans ACM
+ Un rôle IAM avec des autorisations d'exportation ACM (voir) [Autorisations requises](#acm-cert-automation-permissions)
+ AWSinformations d'identification disponibles sur l'instance (profil d'instance, variables d'environnement ou fichier d'informations d'identification)

## Installez le fournisseur
<a name="acm-cert-automation-install"></a>

------
#### [ Linux ]

1. 

**Construisez le fournisseur**

   Créez le binaire du fournisseur à partir de la source ou procurez-vous le binaire prédéfini pour votre plateforme. Suivez les instructions de la section [Installer Rust](https://www.rust-lang.org/tools/install) pour installer la chaîne d'outils Rust.

   ```
   cargo build --release
   ```

   Le fichier exécutable se trouve à`target/release/aws-workload-credentials-provider`.

1. 

**Création d'un fichier de configuration**

   Créez un fichier de configuration TOML avec les détails de votre certificat. Pour obtenir des exemples, consultez [Configuration du fournisseur](#acm-cert-automation-configure). Le programme d'installation copie `/etc/aws-workload-credentials-provider/config.toml` automatiquement ce fichier lorsque vous utilisez l'`--config`option.

1. 

**Exécutez le programme d'installation d’.**

   Exécutez le script d'installation en tant que root :

   ```
   cd aws_workload_credentials_provider_common/configuration
   sudo ./install --config /path/to/your/config.toml
   ```

1. 

**(Facultatif) FournirAWSinformations d’identification**

   Sur les instances Amazon EC2 associées à un profil d'instance, le fournisseur obtient automatiquement les informations d'identification. Pour les autres environnements, créez un fichier de remplacement systemd pour injecter les informations d'identification :

   ```
   sudo mkdir -p /etc/systemd/system/aws-workload-credentials-provider-acm.service.d
   sudo tee /etc/systemd/system/aws-workload-credentials-provider-acm.service.d/creds.conf > /dev/null <<EOF
   [Service]
   Environment="AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE"
   Environment="AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
   Environment="AWS_REGION=us-west-2"
   EOF
   sudo systemctl daemon-reload
   sudo systemctl restart aws-workload-credentials-provider-acm
   ```

------
#### [ Windows ]

1. 

**Créez ou obtenez le fournisseur**

   Créez le binaire du fournisseur à partir du code source pour Windows ou procurez-vous le binaire prédéfini. Suivez les instructions de la section [Installer Rust](https://www.rust-lang.org/tools/install) pour installer la chaîne d'outils Rust.

   ```
   cargo build --release
   ```

   Le fichier exécutable se trouve à`target\release\aws-workload-credentials-provider.exe`.

1. 

**Création d'un fichier de configuration**

   Créez un fichier de configuration TOML avec les détails de votre certificat. Pour obtenir des exemples, consultez [Configuration du fournisseur](#acm-cert-automation-configure). Le programme d'installation copie `C:\ProgramData\AWS\WorkloadCredentialsProvider\config.toml` automatiquement ce fichier lorsque vous utilisez le `-Config` paramètre.

1. 

**Exécutez le programme d'installation d’.**

   Exécutez le script d'installation en tant qu'administrateur :

   ```
   cd aws_workload_credentials_provider_common\configuration
   .\install.ps1 -Config C:\path\to\your\config.toml
   ```

   Pour effectuer l'installation sans démarrer le service, procédez comme suit :

   ```
   .\install.ps1 -Config C:\path\to\your\config.toml -NoStart
   ```

1. 

**(Facultatif) FournirAWSinformations d’identification**

   Sur les instances Amazon EC2 associées à un profil d'instance, le fournisseur obtient automatiquement les informations d'identification via IMDS. Pour les autres environnements, définissez des variables d'environnement pour le service via le registre Windows :

   ```
   $regPath = "HKLM:\SYSTEM\CurrentControlSet\Services\AWSWorkloadCredentialsProvider-ACM"
   $envVars = @(
       "AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE",
       "AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
       "AWS_REGION=us-west-2"
   )
   New-ItemProperty -Path $regPath -Name "Environment" -Value $envVars -PropertyType MultiString -Force
   Restart-Service AWSWorkloadCredentialsProvider-ACM
   ```

------

## Configuration du fournisseur
<a name="acm-cert-automation-configure"></a>

Créez un fichier de configuration TOML avec les détails de votre certificat. Le programme d'installation copie ce fichier `/etc/aws-workload-credentials-provider/config.toml` lorsque vous utilisez l'`--config`option.

------
#### [ NGINX ]

```
[logging]
log_level = "info"
log_to_file = true

[capabilities.acm]
enabled = true

[[capabilities.acm.certificates]]
certificate_arn = "arn:aws:acm:us-west-2:123456789012:certificate/abcd1234-5678-90ab-cdef-EXAMPLE11111"
role_arn = "arn:aws:iam::123456789012:role/ACMExportRole"
certificate_path = "/etc/pki/tls/certs/example.com.crt"
private_key_path = "/etc/pki/tls/private/example.com.key"
chain_path = "/etc/pki/tls/certs/example.com-chain.pem"
refresh_command = "/usr/sbin/nginx -s reload"
```

------
#### [ Apache ]

```
[logging]
log_level = "info"
log_to_file = true

[capabilities.acm]
enabled = true

[[capabilities.acm.certificates]]
certificate_arn = "arn:aws:acm:us-west-2:123456789012:certificate/abcd1234-5678-90ab-cdef-EXAMPLE11111"
role_arn = "arn:aws:iam::123456789012:role/ACMExportRole"
certificate_path = "/etc/ssl/certs/example.com.crt"
private_key_path = "/etc/ssl/private/example.com.key"
chain_path = "/etc/ssl/certs/example.com-chain.pem"
refresh_command = "/bin/systemctl reload httpd"
```

------
#### [ Apache (Windows) ]

```
[logging]
log_level = "info"
log_to_file = true

[capabilities.acm]
enabled = true

[[capabilities.acm.certificates]]
certificate_arn = "arn:aws:acm:us-west-2:123456789012:certificate/abcd1234-5678-90ab-cdef-EXAMPLE11111"
role_arn = "arn:aws:iam::123456789012:role/ACMExportRole"
certificate_path = 'C:\Apache24\conf\ssl\example.com.crt'
private_key_path = 'C:\Apache24\conf\ssl\example.com.key'
chain_path = 'C:\Apache24\conf\ssl\example.com-chain.pem'
refresh_command = 'C:\Apache24\bin\httpd.exe -k restart'
```

------

**Note**  
Lorsqu'elle `chain_path` est omise, la chaîne de certificats est ajoutée au fichier à l'adresse `certificate_path` pour produire un fichier de chaîne complète. Ceci est compatible avec les serveurs Web qui attendent un seul fichier contenant le certificat et sa chaîne.

### Rechargement dynamique de la configuration
<a name="acm-cert-automation-reload"></a>

Vous pouvez mettre à jour la configuration du fournisseur sans la réinstaller en exécutant la `acm reload` commande. Cela valide la nouvelle configuration, met à jour les autorisations pour qu'elles correspondent aux nouveaux chemins de certificat et redémarre le service.

Les certificats supprimés de la configuration cessent d'être actualisés. Les nouveaux certificats commencent immédiatement leur première exportation. Chaque certificat s'exécute en tant que tâche indépendante, de sorte que l'échec de l'un d'entre eux n'affecte pas les autres.

------
#### [ Linux ]

```
aws-workload-credentials-provider acm reload --config /path/to/new-config.toml
```

------
#### [ Windows ]

```
& 'C:\Program Files\AWS\WorkloadCredentialsProvider\bin\aws-workload-credentials-provider.exe' acm reload -Config C:\path\to\new-config.toml
```

------

## Autorisations requises
<a name="acm-cert-automation-permissions"></a>

### Informations d'identification de base
<a name="acm-cert-automation-permissions-base"></a>

Les informations d'identification de base du fournisseur (profil d'instance ou environnement) doivent être en mesure d'assumer le rôle spécifié dans chaque certificat `role_arn` :

```
{
    "Effect": "Allow",
    "Action": "sts:AssumeRole",
    "Resource": "arn:aws:iam::123456789012:role/ACMExportRole"
}
```

### Rôle d'exportation de certificats
<a name="acm-cert-automation-permissions-export-role"></a>

Le rôle spécifié dans `role_arn` nécessite les autorisations suivantes :

```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "acm:ExportCertificate",
            "Resource": "arn:aws:acm:us-west-2:123456789012:certificate/*"
        }
    ]
}
```

La politique de confiance du rôle doit permettre à l'identité de base du fournisseur de l'assumer :

```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::123456789012:role/EC2InstanceRole"
            },
            "Action": "sts:AssumeRole"
        }
    ]
}
```

### Actualiser les autorisations de commande (Linux)
<a name="acm-cert-automation-permissions-refresh"></a>

Sous Linux, le fournisseur exécute la configuration `refresh_command` via`sudo`. Le programme d'installation génère une entrée sudoers `/etc/sudoers.d/aws-workload-credentials-provider` qui permet à l'utilisateur du fournisseur d'exécuter la commande configurée exactement sans demander de mot de passe.

**Important**  
Assurez-vous d'`/etc/sudoers`inclure le `/etc/sudoers.d` répertoire. Le programme d'installation avertit si cette directive d'inclusion n'est pas présente. Sans cela, le fichier sudoers généré n'a aucun effet et les commandes d'actualisation échoueront.

Sous Windows, le fournisseur déclenche la tâche `refresh_command` en tant que tâche planifiée SYSTEM.

## Vérifier l'installation
<a name="acm-cert-automation-verify"></a>

Après l'installation, vérifiez que le fournisseur fonctionne et que les certificats sont en cours d'écriture :

------
#### [ Linux ]

1. **Vérifiez l'état du service :**

   ```
   sudo systemctl status aws-workload-credentials-provider-acm
   ```

1. **Consultez les journaux des fournisseurs :**

   ```
   cat /opt/aws/workload-credentials-provider/logs/acm_provider.log
   ```

1. **Vérifiez que les fichiers de certificat existent :**

   ```
   ls -la /etc/pki/tls/certs/example.com.crt
   ls -la /etc/pki/tls/private/example.com.key
   ```

1. **Validez le contenu du certificat :**

   ```
   openssl x509 -in /etc/pki/tls/certs/example.com.crt -noout -subject -dates
   ```

------
#### [ Windows ]

1. **Vérifiez l'état du service :**

   ```
   Get-Service AWSWorkloadCredentialsProvider-ACM | Format-List Name, Status, StartType
   ```

1. **Consultez les journaux des fournisseurs :**

   ```
   Get-Content "C:\ProgramData\AWS\WorkloadCredentialsProvider\logs\acm_provider.log" -Tail 20
   ```

1. **Vérifiez que les fichiers de certificat existent :**

   ```
   Get-Item C:\certs\example.com.crt
   Get-Item C:\certs\example.com.key
   ```

1. **Validez le contenu du certificat :**

   ```
   $cert = New-Object System.Security.Cryptography.X509Certificates.X509Certificate2("C:\certs\example.com.crt")
   $cert | Select-Object Subject, NotBefore, NotAfter
   ```

------

## Référence de configuration
<a name="acm-cert-automation-config-reference"></a>


| Champ | Obligatoire | Par défaut | Description | 
| --- | --- | --- | --- | 
| logging.log\_level | Non | info | Verbosité de journalisation :debug,,info, warn error none | 
| logging.log\_to\_file | Non | true | Écrire les journaux dans le fichier (true) ou stdout/stderr (false) | 
| capabilities.acm.enabled | Non | false | Activer ou désactiver la fonctionnalité ACM | 
| certificates[].certificate\_arn | Oui | — | ARN du certificat ACM à exporter | 
| certificates[].role\_arn | Oui | — | Rôle IAM (ARN) à assumer pour l'appel ExportCertificate | 
| certificates[].certificate\_path | Oui | — | Chemin absolu pour écrire le fichier de certificat | 
| certificates[].private\_key\_path | Oui | — | Chemin absolu pour écrire le fichier de clé privée | 
| certificates[].chain\_path | Non | — | Chemin absolu pour écrire la chaîne de certificats. En cas d'omission, la chaîne est ajoutée à certificate\_path | 
| certificates[].refresh\_command | Non | — | Commande à exécuter après la mise à jour des fichiers de certificats. Doit être un chemin absolu | 
| certificates[].certificate\_and\_chain\_permission | Non | 0600 | Autorisations de fichier pour les fichiers de certificat et de chaîne (modeformat Linux) | 
| certificates[].key\_permission | Non | 0600 | Autorisations de fichier pour le fichier de clé privée (modeformat Linux) | 

## Logging
<a name="acm-cert-automation-logging"></a>

Sous Linux, le fournisseur se connecte à`/opt/aws/workload-credentials-provider/logs/acm_provider.log`.

Sous Windows, le fournisseur se connecte à`C:\ProgramData\AWS\WorkloadCredentialsProvider\logs\acm_provider.log`. Les événements de démarrage et d'arrêt du service sont également enregistrés dans le journal des événements des applications Windows sous la source`AWSWorkloadCredentialsProvider-ACM`.

**Rotation des journaux** : le fournisseur crée un nouveau fichier journal lorsque le fichier actuel atteint 10 Mo et stocke jusqu'à cinq fichiers journaux archivés.

**AWSjournalisation des services** — Lorsque le fournisseur appelle`ExportCertificate`, cet appel est enregistré AWS CloudTrail avec une chaîne d'agent utilisateur contenant`aws-workload-credentials-provider`. Les opérations internes du fournisseur (cycles du planificateur, écritures de fichiers) apparaissent uniquement dans le journal local.

Vous pouvez configurer la journalisation à l'aide `log_level` des `log_to_file` paramètres et. Pour de plus amples informations, veuillez consulter [Référence de configuration](#acm-cert-automation-config-reference).