È stata rilasciata la versione 5 (V5) di\$1 AWS Strumenti per PowerShell
Per informazioni sulle modifiche introduttive e sulla migrazione delle applicazioni, consulta l'argomento sulla [migrazione](https://docs.aws.amazon.com/powershell/v5/userguide/migrating-v5.html).
[https://docs.aws.amazon.com/powershell/v5/userguide/migrating-v5.html](https://docs.aws.amazon.com/powershell/v5/userguide/migrating-v5.html)
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à.
# Configurazione e utilizzo di AWS Strumenti per PowerShell
In alcuni argomenti di questa sezione vengono descritti i fondamenti dell'utilizzo degli Strumenti per Windows PowerShell dopo l'[installazione degli strumenti e la configurazione](pstools-getting-set-up.md) dell'autenticazione. Ad esempio, spiegano come specificare la [AWS regione](pstools-installing-specifying-region.md) con cui gli strumenti PowerShell devono essere utilizzati per interagire. AWS
Gli altri argomenti di questa sezione forniscono informazioni sui modi avanzati di configurazione degli strumenti, dell'ambiente e dei progetti.
**Topics**
+ [AWS Regione](pstools-installing-specifying-region.md)
+ [Risoluzione di credenziali e profili](creds-assign.md)
+ [Configurazione dell'identità federata](saml-pst.md)
+ [Osservabilità](observability.md)
+ [Individuazione di cmdlet e alias](pstools-discovery-aliases.md)
+ [Pipeline, output e iterazione](pstools-pipelines.md)
+ [Utenti e ruoli](pstools-users-roles.md)
+ [Uso delle credenziali legacy](pstools-cred-legacy.md)
# Specificare la AWS regione per AWS Strumenti per PowerShell
Esistono due modi per specificare la AWS regione da utilizzare per l'esecuzione dei AWS Strumenti per PowerShell comandi:
+ Utilizza il parametro `-Region` comune sui singoli comandi.
+ Utilizza il comando `Set-DefaultAWSRegion` per impostare una regione predefinita per tutti i comandi.
Molti AWS cmdlet hanno esito negativo se gli Strumenti per Windows non PowerShell riescono a capire quale regione utilizzare. Le eccezioni includono i cmdlet per Amazon S3[, Amazon](pstools-s3.md) SES AWS Identity and Access Management e, che utilizzano automaticamente per impostazione predefinita un endpoint globale.
**Per specificare la regione per un singolo comando AWS **
Aggiungi il parametro `-Region` al comando, come il seguente.
```
PS > Get-EC2Image -Region us-west-2
```
**Per impostare una regione predefinita per tutti i comandi AWS CLI nella sessione corrente**
Dal PowerShell prompt dei comandi, digitare il comando seguente.
```
PS > Set-DefaultAWSRegion -Region us-west-2
```
**Nota**
Questa impostazione persiste solo nella sessione corrente. Per applicare l'impostazione a tutte le PowerShell sessioni, aggiungi questo comando al tuo PowerShell profilo come hai fatto per il `Import-Module` comando.
**Per visualizzare l'area predefinita corrente per tutti i comandi AWS CLI**
Dal PowerShell prompt dei comandi, digitare il seguente comando.
```
PS > Get-DefaultAWSRegion
Region Name IsShellDefault
------ ---- --------------
us-west-2 US West (Oregon) True
```
**Per cancellare la regione predefinita corrente per tutti i comandi AWS CLI**
Dal PowerShell prompt dei comandi, digitate il seguente comando.
```
PS > Clear-DefaultAWSRegion
```
**Per visualizzare un elenco di tutte le regioni disponibili AWS **
Dal PowerShell prompt dei comandi, digitare il comando seguente. La terza colonna nell'output di esempio identifica la Regione predefinita per la sessione corrente.
```
PS > Get-AWSRegion
Region Name IsShellDefault
------ ---- --------------
ap-east-1 Asia Pacific (Hong Kong) False
ap-northeast-1 Asia Pacific (Tokyo) False
...
us-east-2 US East (Ohio) False
us-west-1 US West (N. California) False
us-west-2 US West (Oregon) True
...
```
**Nota**
Alcune Regioni potrebbero essere supportate ma non incluse negli output del cmdlet `Get-AWSRegion`. Ad esempio, questo è talvolta vero per le Regioni che non sono ancora globali. Se non sei in grado di specificare una Regione aggiungendo il parametro `-Region` a un comando, prova invece a specificare la Regione in un endpoint personalizzato, come illustrato nella sezione successiva.
## Specificare un endpoint personalizzato o non standard
Specificate un endpoint personalizzato come URL aggiungendo il parametro `-EndpointUrl` common al PowerShell comando Tools for Windows, nel seguente formato di esempio.
```
PS > Some-AWS-PowerShellCmdlet -EndpointUrl "custom endpoint URL" -Other -Parameters
```
L'esempio seguente utilizza il cmdlet `Get-EC2Instance`. L'endpoint personalizzato si trova in `us-west-2` o nella Regione Stati Uniti occidentali (Oregon) in questo esempio, ma puoi utilizzare qualsiasi altra Regione AWS supportata, incluse le Regioni che non sono enumerate da `Get-AWSRegion`.
```
PS > Get-EC2Instance -EndpointUrl "https://service-custom-url.us-west-2.amazonaws.com" -InstanceID "i-0555a30a2000000e1"
```
## Informazioni aggiuntive
Per ulteriori informazioni sulle AWS regioni, vedere [AWS Region nella AWS](https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html) *SDKs and Tools Reference Guide*.
# Risoluzione di credenziali e profili
## Ordine di ricerca credenziali
Quando si esegue un comando, AWS Strumenti per PowerShell cerca le credenziali nell'ordine seguente. Si interrompe quando trova le credenziali utilizzabili.
1. Credenziali letterali incorporate come parametri nella riga di comando.
Consigliamo di utilizzare i profili anziché inserire credenziali letterali nelle righe di comando.
1. Credenziali specificate dal parametro `-Credential`.
1. Un nome di profilo o una posizione del profilo che è stato specificato utilizzando il cmdlet [Set- AWSCredential](https://docs.aws.amazon.com/powershell/v5/reference/items/Set-AWSCredential.html).
+ Se si specifica solo un nome di profilo, il comando cerca il profilo specificato nell'archivio AWS SDK e, se non esiste, il profilo specificato dal file delle credenziali AWS condivise nella posizione predefinita.
+ Se specifichi solo una posizione del profilo, il comando cerca il profilo `default` dal file delle credenziali.
+ Se specifichi sia un nome sia un percorso, il comando cerca il profilo specificato nel file delle credenziali.
Se il profilo specificato o il percorso non è stato trovato, il comando genera un'eccezione. La ricerca procede nelle seguenti fasi solo se non hai specificato un profilo o una posizione.
1. Credenziali create dalle variabili di `AWS_SESSION_TOKEN` ambiente `AWS_ACCESS_KEY_ID``AWS_SECRET_ACCESS_KEY`, e se tutte e tre le variabili hanno un valore.
1. Il profilo delle credenziali con il nome specificato dalla variabile di `AWS_PROFILE` ambiente.
1. Il profilo predefinito nell'ordine seguente:
1. Il `default` profilo nell'archivio AWS SDK.
1. Il `default` profilo nel AWS `credentials` file condiviso.
1. Il `AWS PS Default` profilo nell'archivio AWS SDK.
1. Se il comando è in esecuzione su un' EC2 istanza Amazon configurata per utilizzare un ruolo IAM, le credenziali temporanee dell' EC2istanza sono accessibili dal profilo dell'istanza.
Per ulteriori informazioni sull'utilizzo dei ruoli IAM per EC2 le istanze Amazon, consulta [Granting access with a role](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-hosm.html) nella [AWS SDK per .NET Developer](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/) Guide.
Se la ricerca ha esito negativo per individuare le credenziali specificate, il comando genera un'eccezione.
Per ulteriori informazioni sulle variabili di ambiente e sui profili di credenziali, consulta i seguenti argomenti nella [AWS SDKs and Tools Reference Guide](https://docs.aws.amazon.com/sdkref/latest/guide/): variabili di [ambiente, elenco delle variabili](https://docs.aws.amazon.com/sdkref/latest/guide/environment-variables.html) [di ambiente](https://docs.aws.amazon.com/sdkref/latest/guide/settings-reference.html#EVarSettings) e file di [configurazione e credenziali condivisi](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html).
# Configurare l'identità federata con AWS Strumenti per PowerShell
Per consentire agli utenti dell'organizzazione di accedere alle AWS risorse, è necessario configurare un metodo di autenticazione standard e ripetibile per scopi di sicurezza, verificabilità, conformità e capacità di supportare la separazione di ruoli e account. Sebbene sia comune fornire agli utenti la possibilità di accedere AWS APIs, senza l'accesso alle API federate, è necessario creare anche utenti AWS Identity and Access Management (IAM), il che vanifica lo scopo dell'utilizzo della federazione. Questo argomento descrive il supporto SAML (Security Assertion Markup Language) AWS Strumenti per PowerShell che semplifica la soluzione di accesso federato.
Il supporto SAML AWS Strumenti per PowerShell consente di fornire agli utenti un accesso federato ai servizi. AWS SAML è un formato standard aperto basato su XML per la trasmissione dei dati di autenticazione e autorizzazione degli utenti tra i servizi, in particolare tra un provider di identità (come [Active Directory Federation Services) e un fornitore di servizi](https://learn.microsoft.com/en-us/windows-server/identity/ad-fs/ad-fs-overview) (come). AWS Per ulteriori informazioni su SAML e su come funziona, consultare la pagina [SAML](https://en.wikipedia.org/wiki/Security_Assertion_Markup_Language) su Wikipedia o [SAML Technical Specifications](https://www.oasis-open.org/standard/saml/) sul sito del consorzio della Organization for the Advancement of Structured Information Standards (OASIS). Il supporto SAML in è compatibile con SAML 2.0 AWS Strumenti per PowerShell .
## Prerequisiti
È necessario soddisfare i seguenti prerequisiti prima di provare a utilizzare il supporto a SAML per la prima volta.
+ Una soluzione di identità federata correttamente integrata con l'account AWS per l'accesso alla console utilizzando solo le credenziali della propria organizzazione. Per ulteriori informazioni su come eseguire questa operazione, in particolare per Active Directory Federation Services, consulta [About SAML 2.0 Federation](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html) nella *IAM User Guide* e il post del blog [Enabling Federation to AWS Using Windows Active Directory, AD FS e](https://aws.amazon.com/blogs/security/enabling-federation-to-aws-using-windows-active-directory-adfs-and-saml-2-0/) SAML 2.0. Anche se il blog post copre AD FS 2.0, le fasi sono simili se si esegue AD FS 3.0.
+ Versione 3.1.31.0 o successiva di quella AWS Strumenti per PowerShell installata sulla workstation locale.
## In che modo un utente con identità federata ottiene l'accesso federato al servizio AWS APIs
Il processo seguente descrive, a livello generale, in che modo un utente di Active Directory (AD) viene federato da AD FS per accedere alle risorse. AWS
![\[Diagram showing federated user access flow to AWS resources via AD FS and Security Token Service.\]](http://docs.aws.amazon.com/it_it/powershell/v5/userguide/images/powershell_ADFSauth_using_vsd.png)
1. Il client nel computer dell'utente federato esegue l'autenticazione tramite AD FS.
1. Se l'autenticazione ha esito positivo, AD FS invia all'utente un'asserzione SAML.
1. Il client dell'utente invia l'asserzione SAML a AWS Security Token Service (STS) come parte di una richiesta di federazione SAML.
1. STS restituisce una risposta SAML che contiene credenziali AWS temporanee per un ruolo che l'utente può assumere.
1. L'utente accede al AWS servizio APIs includendo tali credenziali temporanee nella richiesta effettuata da. AWS Strumenti per PowerShell
## Come funziona il supporto SAML nel AWS Strumenti per PowerShell
Questa sezione descrive come i AWS Strumenti per PowerShell cmdlet abilitano la configurazione della federazione delle identità basata su SAML per gli utenti.
![\[Diagram showing SAML-based federation flow between organization, AD FS, AWS, and service APIs.\]](http://docs.aws.amazon.com/it_it/powershell/v5/userguide/images/Powershell_SamlAuth_using_vsd.png)
1. AWS Strumenti per PowerShell esegue l'autenticazione con AD FS utilizzando le credenziali correnti dell'utente Windows o in modo interattivo, quando l'utente tenta di eseguire un cmdlet che richiede credenziali per la chiamata. AWS
1. AD FS autentica l'utente.
1. AD FS genera una risposta di autenticazione SAML 2.0 che include un'asserzione; lo scopo dell'asserzione è identificare e fornire informazioni sull'utente. AWS Strumenti per PowerShell estrae l'elenco dei ruoli autorizzati dell'utente dall'asserzione SAML.
1. AWS Strumenti per PowerShell inoltra la richiesta SAML, inclusi gli Amazon Resource Names (ARN) del ruolo richiesto, a STS effettuando la chiamata API. `AssumeRoleWithSAMLRequest`
1. Se la richiesta SAML è valida, STS restituirà una risposta che contiene i parametri `AccessKeyId`, `SecretAccessKey` e `SessionToken` di AWS . Queste credenziali dureranno per 3.600 secondi (1 ora).
1. L'utente ora dispone di credenziali valide per lavorare con qualsiasi AWS servizio a APIs cui il ruolo dell'utente è autorizzato ad accedere. AWS Strumenti per PowerShell applica automaticamente queste credenziali per tutte le chiamate AWS API successive e le rinnova automaticamente quando scadono.
**Nota**
Quando le credenziali scadono e sono necessarie nuove credenziali, gli AWS Strumenti per PowerShell eseguono automaticamente una nuova autenticazione con AD FS e ottengono nuove credenziali per l'ora successiva. Per gli account degli utenti aggiunti al dominio, questo processo viene eseguito automaticamente. Per gli account che non fanno parte di un dominio, AWS Strumenti per PowerShell richiede agli utenti di inserire le proprie credenziali prima di poter effettuare nuovamente l'autenticazione.
## Come utilizzare i cmdlet di configurazione SAML PowerShell
AWS Strumenti per PowerShell include due nuovi cmdlet che forniscono il supporto SAML.
+ `Set-AWSSamlEndpoint` configura gli endpoint AD FS, assegna un nome descrittivo per l'endpoint e, facoltativamente, descrive il tipo di autenticazione dell'endpoint.
+ `Set-AWSSamlRoleProfile` crea o modifica un profilo di account utente che si desidera associare a un endpoint AD FS, identificato specificando il nome descrittivo fornito al cmdlet `Set-AWSSamlEndpoint`. Ogni ruolo del profilo viene mappato a un singolo ruolo che un utente è autorizzato a eseguire.
Proprio come con i profili di AWS credenziali, si assegna un nome descrittivo al profilo del ruolo. È possibile utilizzare lo stesso nome descrittivo con il `Set-AWSCredential` cmdlet o come valore del `-ProfileName` parametro per qualsiasi cmdlet che richiama il servizio. AWS APIs
Aprire una nuova sessione. AWS Strumenti per PowerShell Se si esegue la PowerShell versione 3.0 o una versione successiva, il AWS Strumenti per PowerShell modulo viene importato automaticamente quando si esegue uno dei relativi cmdlet. Se si esegue la PowerShell versione 2.0, è necessario importare il modulo manualmente eseguendo il cmdlet ``Import-Module``, come illustrato nell'esempio seguente.
```
PS > Import-Module "C:\Program Files (x86)\AWS Tools\PowerShell\AWSPowerShell\AWSPowerShell.psd1"
```
### Come eseguire i cmdlet `Set-AWSSamlEndpoint` e `Set-AWSSamlRoleProfile`
1. In primo luogo, configurare le impostazioni degli endpoint per il sistema AD FS. Il modo più semplice per eseguire questa operazione è quello di archiviare l'endpoint in una variabile, come illustrato in questa fase. Assicurati di sostituire l'account segnaposto e il nome host AD FS con il tuo account IDs e il tuo nome host AD FS. IDs Specificare il nome dell'host dell'AD FS nel parametro `Endpoint`.
```
PS > $endpoint = "https://adfs.example.com/adfs/ls/IdpInitiatedSignOn.aspx?loginToRp=urn:amazon:webservices"
```
1. Per creare le impostazioni dell'endpoint, eseguire il cmdlet `Set-AWSSamlEndpoint` specificando il valore corretto per il parametro `AuthenticationType`. I valori validi includono `Basic`, `Digest`, `Kerberos`, `Negotiate` e `NTLM`. Se non viene specificato questo parametro, il valore predefinito è `Kerberos`.
```
PS > $epName = Set-AWSSamlEndpoint -Endpoint $endpoint -StoreAs ADFS-Demo -AuthenticationType NTLM
```
Il cmdlet restituisce il nome descrittivo assegnato utilizzando il parametro `-StoreAs`, in modo che sia possibile utilizzarlo quando si esegue `Set-AWSSamlRoleProfile` nella riga successiva.
1. Ora, esegui il cmdlet `Set-AWSSamlRoleProfile` per effettuare l'autenticazione con il fornitore di identità AD FS e ottenere il set dei ruoli (nell'asserzione SAML) che l'utente è autorizzato a eseguire.
Il cmdlet `Set-AWSSamlRoleProfile` utilizza il set di ruoli restituito per richiedere all'utente di selezionare un ruolo per associarlo con il profilo specificato o convalidare i dati forniti del ruolo in parametri se presenti (in caso contrario all'utente viene richiesto di scegliere). Se l'utente è autorizzato per un solo ruolo, il cmdlet associa il ruolo con il profilo automaticamente, senza richiedere l'intervento dell'utente. Non è necessario fornire credenziali per configurare un profilo per l'utilizzo aggiunto al dominio.
```
PS > Set-AWSSamlRoleProfile -StoreAs SAMLDemoProfile -EndpointName $epName
```
In alternativa, per non-domain-joined gli account, puoi fornire le credenziali di Active Directory e quindi selezionare un AWS ruolo a cui l'utente ha accesso, come illustrato nella riga seguente. Questa funzione è utile se si dispone di diversi account utente Active Directory per distinguere i ruoli all'interno della propria organizzazione (ad esempio per le funzioni di amministrazione).
```
PS > $credential = Get-Credential -Message "Enter the domain credentials for the endpoint"
PS > Set-AWSSamlRoleProfile -EndpointName $epName -NetworkCredential $credential -StoreAs SAMLDemoProfile
```
1. In entrambi i casi, il cmdlet `Set-AWSSamlRoleProfile` richiede di scegliere quale ruolo deve essere memorizzato nel profilo. Il seguente esempio mostra due ruoli disponibili: `ADFS-Dev` e `ADFS-Production`. I ruoli IAM sono associati alle tue credenziali di accesso AD dall'amministratore di AD FS.
```
Select Role
Select the role to be assumed when this profile is active
[1] 1 - ADFS-Dev [2] 2 - ADFS-Production [?] Help (default is "1"):
```
In alternativa, puoi specificare un ruolo senza il prompt, inserendo i parametri `RoleARN`, `PrincipalARN` e `NetworkCredential` opzionale. Se il ruolo specificato non è elencato nell'asserzione restituita dall'autenticazione, all'utente viene richiesto di scegliere tra i ruoli disponibili.
```
PS > $params = @{ "NetworkCredential"=$credential, "PrincipalARN"="{arn:aws:iam::012345678912:saml-provider/ADFS}", "RoleARN"="{arn:aws:iam::012345678912:role/ADFS-Dev}"
}
PS > $epName | Set-AWSSamlRoleProfile @params -StoreAs SAMLDemoProfile1 -Verbose
```
1. È possibile creare profili per tutti i ruoli in un unico comando aggiungendo il parametro `StoreAllRoles`, come mostrato nel codice seguente. Si noti che il nome del ruolo viene usato come nome del profilo.
```
PS > Set-AWSSamlRoleProfile -EndpointName $epName -StoreAllRoles
ADFS-Dev
ADFS-Production
```
### Come utilizzare i profili di ruolo per eseguire cmdlet che richiedono credenziali AWS
Per eseguire cmdlet che richiedono AWS credenziali, è possibile utilizzare i profili di ruolo definiti nel file di credenziali condiviso. AWS Fornite il nome di un profilo di ruolo a `Set-AWSCredential` (o come valore per qualsiasi `ProfileName` parametro in AWS Strumenti per PowerShell) per ottenere automaticamente AWS le credenziali temporanee per il ruolo descritto nel profilo.
Anche se si utilizza un solo profilo del ruolo alla volta, è possibile passare tra i profili all'interno di una sessione shell. Il cmdlet `Set-AWSCredential` non autentica e non ottiene le credenziali quando viene eseguito di per sé; il cmdlet registra il desiderio di utilizzare un specifico profilo di ruolo. Finché esegui un cmdlet che richiede le credenziali AWS , non occorre l'autenticazione o la richiesta di credenziali.
È ora possibile utilizzare le AWS credenziali temporanee ottenute con il `SAMLDemoProfile` profilo per lavorare con AWS il servizio. APIs Le seguenti sezioni mostrano degli esempi su come utilizzare i profili di ruolo.
### Esempio 1: Impostare un ruolo predefinito con `Set-AWSCredential`
Questo esempio imposta un ruolo predefinito per una AWS Strumenti per PowerShell sessione utilizzando`Set-AWSCredential`. Quindi, è possibile eseguire i cmdlet che richiedono le credenziali e sono autorizzati dal ruolo specificato. In questo esempio vengono elencate tutte le istanze Amazon Elastic Compute Cloud nella Regione Stati Uniti occidentali (Oregon) associate al profilo specificato con il cmdlet `Set-AWSCredential`.
```
PS > Set-AWSCredential -ProfileName SAMLDemoProfile
PS > Get-EC2Instance -Region us-west-2 | Format-Table -Property Instances,GroupNames
Instances GroupNames
--------- ----------
{TestInstance1} {default}
{TestInstance2} {}
{TestInstance3} {launch-wizard-6}
{TestInstance4} {default}
{TestInstance5} {}
{TestInstance6} {AWS-OpsWorks-Default-Server}
```
### Esempio 2: modifica dei profili dei ruoli durante una PowerShell sessione
Questo esempio elenca tutti i bucket Amazon S3 disponibili nell' AWS account del ruolo associato al profilo. `SAMLDemoProfile` L'esempio mostra che, sebbene sia stato possibile utilizzare un altro profilo in precedenza nella AWS Strumenti per PowerShell sessione, è possibile modificare i profili specificando un valore diverso per il `-ProfileName` parametro con i cmdlet che lo supportano. Si tratta di un'attività comune per gli amministratori che gestiscono Amazon S3 PowerShell dalla riga di comando.
```
PS > Get-S3Bucket -ProfileName SAMLDemoProfile
CreationDate BucketName
------------ ----------
7/25/2013 3:16:56 AM amzn-s3-demo-bucket
4/15/2015 12:46:50 AM amzn-s3-demo-bucket1
4/15/2015 6:15:53 AM amzn-s3-demo-bucket2
1/12/2015 11:20:16 PM amzn-s3-demo-bucket3
```
Si noti che il cmdlet `Get-S3Bucket` specifica il nome del profilo creato eseguendo il cmdlet `Set-AWSSamlRoleProfile`. Questo comando può essere utile se è stato impostato un profilo all'inizio della sessione (per esempio, eseguendo il cmdlet `Set-AWSCredential`) e si voleva utilizzare un profilo di ruolo differente per il cmdlet `Get-S3Bucket`. Il gestore del profilo rende disponibili le credenziali provvisorie al cmdlet `Get-S3Bucket`.
Anche se le credenziali scadono dopo 1 ora (un limite imposto da STS), gli AWS Strumenti per PowerShell aggiornano automaticamente le credenziali richiedendo una nuova asserzione SAML quando gli strumenti rilevano che le attuali credenziali sono scadute.
Per gli utenti aggiunti al dominio, questo processo viene eseguito senza interruzioni, perché l'attuale identità dell'utente Windows viene utilizzata durante l'autenticazione. Per gli account non-domain-joined utente, AWS Strumenti per PowerShell mostra una richiesta di PowerShell credenziali che richiede la password dell'utente. L'utente fornisce le credenziali che sono state utilizzate per la sua nuova autenticazione e per ottenere una nuova asserzione.
### Esempio 3: Ottenere istanze in una regione
L'esempio seguente elenca tutte le istanze Amazon EC2 nella Regione Asia Pacifico (Sydney) associate all'account utilizzato dal profilo `ADFS-Production`. Si tratta di un comando utile per restituire tutte le istanze Amazon EC2 in una Regione.
```
PS > (Get-Ec2Instance -ProfileName ADFS-Production -Region ap-southeast-2).Instances | Select InstanceType, @{Name="Servername";Expression={$_.tags | where key -eq "Name" | Select Value -Expand Value}}
InstanceType Servername
------------ ----------
t2.small DC2
t1.micro NAT1
t1.micro RDGW1
t1.micro RDGW2
t1.micro NAT2
t2.small DC1
t2.micro BUILD
```
## Ulteriori letture
Per informazioni generali su come implementare l'accesso alle API federate, consulta [Come implementare una soluzione generale per l'accesso federato API/CLI utilizzando SAML](https://aws.amazon.com/blogs/security/how-to-implement-a-general-solution-for-federated-apicli-access-using-saml-2-0/) 2.0.
[Per domande o commenti di supporto, visita i forum per AWS sviluppatori per lo [PowerShell scripting](https://forums.aws.amazon.com/forum.jspa?forumID=149) o.NET Development.](https://forums.aws.amazon.com/forum.jspa?forumID=61)
# Osservabilità
L'osservabilità è la misura in cui lo stato attuale di un sistema può essere dedotto dai dati che emette. I dati emessi vengono comunemente definiti telemetria. [https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/observability.html](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/observability.html)
Il codice seguente mostra un esempio di come l'osservabilità può essere abilitata in. AWS Strumenti per PowerShell
```
<#
This is an example of generating telemetry for AWS Tools for PowerShell.
Each cmdlet that interacts with an Amazon Web Service creates a trace containing spans
for underlying processes and AWS SDK for .NET operations.
This example is written using PowerShell 7 and .NET 8.
It requires the installation of the .NET CLI tool.
Note that implementation varies by the exporter/endpoint, which is not specified in this example.
For more information, see https://opentelemetry.io/docs/languages/net/exporters/.
#>
# Set this value to a common folder path on your computer for local development of code repositories.
$devProjectsPath = [System.IO.Path]::Join('C:', 'Dev', 'Repos')
# If these values are changed, update the hardcoded method invocation toward the end of this script.
# Values must follow constraints for namespaces and classes.
$telemetryProjectName = 'ExampleAWSPowerShellTelemetryImplementation'
$serviceName = 'ExamplePowerShellService'
# This example supposes that the OTLP exporter requires these two properties,
# but some exporters require different properties or no properties.
$telemetryEndPoint = 'https://example-endpoint-provider.io'
$telemetryHeaders = 'x-example-header=abc123'
$dllsPath = [System.IO.Path]::Join($devProjectsPath, $telemetryProjectName, 'bin', 'Release', 'net8.0', 'publish')
$telemetryProjectPath = [System.IO.Path]::Join($devProjectsPath, $telemetryProjectName)
# This script is designed to recreate the example telemetry project each time it's executed.
Remove-Item -Path $telemetryProjectPath -Recurse -Force -ErrorAction 'SilentlyContinue'
$null = New-Item -Path $devProjectsPath -Name $telemetryProjectName -ItemType 'Directory'
<#
Create and build a C#-based .NET 8 project that implements
OpenTelemetry Instrumentation for the AWS Tools for PowerShell.
#>
Set-Location -Path $telemetryProjectPath
dotnet new classlib
# Other exporters are available.
# For more information, see https://opentelemetry.io/docs/languages/net/exporters/.
dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
dotnet add package OpenTelemetry.Instrumentation.AWS
$classContent = @"
using OpenTelemetry;
using OpenTelemetry.Resources;
using OpenTelemetry.Trace;
namespace Example.Telemetry;
public class AWSToolsForPowerShellTelemetry
{
public static void InitializeAWSInstrumentation()
{
Sdk.CreateTracerProviderBuilder()
.ConfigureResource(e => e.AddService("$ServiceName"))
.AddAWSInstrumentation()
// Exporters vary so options might need to be changed or omitted.
.AddOtlpExporter(options =>
{
options.Endpoint = new Uri("$telemetryEndPoint");
options.Headers = "$telemetryHeaders";
})
.Build();
}
}
"@
$csFilePath = [System.IO.Path]::Join($telemetryProjectPath, ($serviceName + '.cs'))
Set-Content -Path $csFilePath -Value $classContent
dotnet build
dotnet publish -c Release
<#
Add additional modules here for any other cmdlets that you require.
Beyond this point, additional AWS Tools for PowerShell modules will fail to import
due to conflicts with the AWS SDK for .NET assemblies that are added next.
#>
Import-Module -Name 'AWS.Tools.Common'
Import-Module -Name 'AWS.Tools.DynamoDBv2'
# Load assemblies for the telemetry project, excluding the AWS SDK for .NET assemblies
# that were already loaded by importing AWS Tools for PowerShell modules.
$dlls = (Get-ChildItem $dllsPath -Filter *.dll -Recurse ).FullName
$AWSSDKAssembliesAlreadyLoaded = [Threading.Thread]::GetDomain().GetAssemblies().Location | Where-Object {$_ -like '*AWSSDK*' } | Split-Path -Leaf
$dlls.Where{$AWSSDKAssembliesAlreadyLoaded -notcontains ($_ | Split-Path -Leaf)}.ForEach{Add-Type -Path $_}
# Invoke the method defined earlier in this script.
[Example.Telemetry.AWSToolsForPowerShellTelemetry]::InitializeAWSInstrumentation()
<#
Now telemetry will be exported for AWS Tools for PowerShell cmdlets
that are invoked directly or indirectly.
Execute this cmdlet or execute your own PowerShell script.
#>
Get-DDBTable -TableName 'DotNetTests-HashTable' -Region 'us-east-1'
```
# Individuazione di cmdlet e alias
Questa sezione illustra come elencare i servizi supportati da AWS Strumenti per PowerShell, come mostrare il set di cmdlet fornito da AWS Strumenti per PowerShell a supporto di tali servizi e come trovare nomi di cmdlet alternativi (chiamati anche alias) per accedere a tali servizi.
## Individuare i cmdlet
Tutte le operazioni (o APIs) del AWS servizio sono documentate nella Guida di riferimento delle API per ogni servizio. Ad esempio, consulta la [Guida di riferimento dell'API IAM](https://docs.aws.amazon.com/IAM/latest/APIReference/). Nella maggior parte dei casi esiste una one-to-one corrispondenza tra un'API di AWS servizio e un AWS PowerShell cmdlet. Per ottenere il nome del cmdlet che corrisponde al nome di un'API di AWS servizio, esegui il AWS `Get-AWSCmdletName` cmdlet con il parametro e il nome dell'API del `-ApiOperation` servizio. AWS Ad esempio, per ottenere tutti i possibili nomi di cmdlet basati su qualsiasi API di `DescribeInstances` AWS servizio disponibile, esegui il comando seguente:
```
PS > Get-AWSCmdletName -ApiOperation DescribeInstances
CmdletName ServiceOperation ServiceName CmdletNounPrefix
---------- ---------------- ----------- ----------------
Get-EC2Instance DescribeInstances Amazon Elastic Compute Cloud EC2
Get-GMLInstance DescribeInstances Amazon GameLift Service GML
```
Il parametro `-ApiOperation` è il parametro predefinito, quindi puoi omettere il nome del parametro. L'esempio seguente è uguale al precedente:
```
PS > Get-AWSCmdletName DescribeInstances
```
Se si conoscono i nomi sia dell'API che del servizio, è possibile includere il `-Service` parametro insieme al prefisso sostantivo del cmdlet o a parte del nome del servizio. AWS Ad esempio, il prefisso sostantivo del cmdlet per Amazon è. EC2 `EC2` Per ottenere il nome del cmdlet che corrisponde all'`DescribeInstances`API nel EC2 servizio Amazon, esegui uno dei seguenti comandi. Sono tutti risultati nello stesso output:
```
PS > Get-AWSCmdletName -ApiOperation DescribeInstances -Service EC2
PS > Get-AWSCmdletName -ApiOperation DescribeInstances -Service Compute
PS > Get-AWSCmdletName -ApiOperation DescribeInstances -Service "Compute Cloud"
CmdletName ServiceOperation ServiceName CmdletNounPrefix
---------- ---------------- ----------- ----------------
Get-EC2Instance DescribeInstances Amazon Elastic Compute Cloud EC2
```
I valori del parametro in questi comandi fanno distinzione tra maiuscola e minuscola.
Se non conosci il nome dell'API di AWS servizio desiderata o del AWS servizio, puoi utilizzare il `-ApiOperation` parametro, insieme al modello da abbinare e al `-MatchWithRegex` parametro. Ad esempio, per ottenere tutti i nomi dei cmdlet disponibili che contengono `SecurityGroup`, esegui il comando seguente:
```
PS > Get-AWSCmdletName -ApiOperation SecurityGroup -MatchWithRegex
CmdletName ServiceOperation ServiceName CmdletNounPrefix
---------- ---------------- ----------- ----------------
Approve-ECCacheSecurityGroupIngress AuthorizeCacheSecurityGroupIngress Amazon ElastiCache EC
Get-ECCacheSecurityGroup DescribeCacheSecurityGroups Amazon ElastiCache EC
New-ECCacheSecurityGroup CreateCacheSecurityGroup Amazon ElastiCache EC
Remove-ECCacheSecurityGroup DeleteCacheSecurityGroup Amazon ElastiCache EC
Revoke-ECCacheSecurityGroupIngress RevokeCacheSecurityGroupIngress Amazon ElastiCache EC
Add-EC2SecurityGroupToClientVpnTargetNetwrk ApplySecurityGroupsToClientVpnTargetNetwork Amazon Elastic Compute Cloud EC2
Get-EC2SecurityGroup DescribeSecurityGroups Amazon Elastic Compute Cloud EC2
Get-EC2SecurityGroupReference DescribeSecurityGroupReferences Amazon Elastic Compute Cloud EC2
Get-EC2StaleSecurityGroup DescribeStaleSecurityGroups Amazon Elastic Compute Cloud EC2
Grant-EC2SecurityGroupEgress AuthorizeSecurityGroupEgress Amazon Elastic Compute Cloud EC2
Grant-EC2SecurityGroupIngress AuthorizeSecurityGroupIngress Amazon Elastic Compute Cloud EC2
New-EC2SecurityGroup CreateSecurityGroup Amazon Elastic Compute Cloud EC2
Remove-EC2SecurityGroup DeleteSecurityGroup Amazon Elastic Compute Cloud EC2
Revoke-EC2SecurityGroupEgress RevokeSecurityGroupEgress Amazon Elastic Compute Cloud EC2
Revoke-EC2SecurityGroupIngress RevokeSecurityGroupIngress Amazon Elastic Compute Cloud EC2
Update-EC2SecurityGroupRuleEgressDescription UpdateSecurityGroupRuleDescriptionsEgress Amazon Elastic Compute Cloud EC2
Update-EC2SecurityGroupRuleIngressDescription UpdateSecurityGroupRuleDescriptionsIngress Amazon Elastic Compute Cloud EC2
Edit-EFSMountTargetSecurityGroup ModifyMountTargetSecurityGroups Amazon Elastic File System EFS
Get-EFSMountTargetSecurityGroup DescribeMountTargetSecurityGroups Amazon Elastic File System EFS
Join-ELBSecurityGroupToLoadBalancer ApplySecurityGroupsToLoadBalancer Elastic Load Balancing ELB
Set-ELB2SecurityGroup SetSecurityGroups Elastic Load Balancing V2 ELB2
Enable-RDSDBSecurityGroupIngress AuthorizeDBSecurityGroupIngress Amazon Relational Database Service RDS
Get-RDSDBSecurityGroup DescribeDBSecurityGroups Amazon Relational Database Service RDS
New-RDSDBSecurityGroup CreateDBSecurityGroup Amazon Relational Database Service RDS
Remove-RDSDBSecurityGroup DeleteDBSecurityGroup Amazon Relational Database Service RDS
Revoke-RDSDBSecurityGroupIngress RevokeDBSecurityGroupIngress Amazon Relational Database Service RDS
Approve-RSClusterSecurityGroupIngress AuthorizeClusterSecurityGroupIngress Amazon Redshift RS
Get-RSClusterSecurityGroup DescribeClusterSecurityGroups Amazon Redshift RS
New-RSClusterSecurityGroup CreateClusterSecurityGroup Amazon Redshift RS
Remove-RSClusterSecurityGroup DeleteClusterSecurityGroup Amazon Redshift RS
Revoke-RSClusterSecurityGroupIngress RevokeClusterSecurityGroupIngress Amazon Redshift RS
```
Se conosci il nome del AWS servizio ma non l'API del AWS servizio, includi sia il `-MatchWithRegex` parametro che il `-Service` parametro per circoscrivere la ricerca a un singolo servizio. Ad esempio, per ottenere tutti i nomi di cmdlet che contengono `SecurityGroup` solo il EC2 servizio Amazon, esegui il comando seguente
```
PS > Get-AWSCmdletName -ApiOperation SecurityGroup -MatchWithRegex -Service EC2
CmdletName ServiceOperation ServiceName CmdletNounPrefix
---------- ---------------- ----------- ----------------
Add-EC2SecurityGroupToClientVpnTargetNetwrk ApplySecurityGroupsToClientVpnTargetNetwork Amazon Elastic Compute Cloud EC2
Get-EC2SecurityGroup DescribeSecurityGroups Amazon Elastic Compute Cloud EC2
Get-EC2SecurityGroupReference DescribeSecurityGroupReferences Amazon Elastic Compute Cloud EC2
Get-EC2StaleSecurityGroup DescribeStaleSecurityGroups Amazon Elastic Compute Cloud EC2
Grant-EC2SecurityGroupEgress AuthorizeSecurityGroupEgress Amazon Elastic Compute Cloud EC2
Grant-EC2SecurityGroupIngress AuthorizeSecurityGroupIngress Amazon Elastic Compute Cloud EC2
New-EC2SecurityGroup CreateSecurityGroup Amazon Elastic Compute Cloud EC2
Remove-EC2SecurityGroup DeleteSecurityGroup Amazon Elastic Compute Cloud EC2
Revoke-EC2SecurityGroupEgress RevokeSecurityGroupEgress Amazon Elastic Compute Cloud EC2
Revoke-EC2SecurityGroupIngress RevokeSecurityGroupIngress Amazon Elastic Compute Cloud EC2
Update-EC2SecurityGroupRuleEgressDescription UpdateSecurityGroupRuleDescriptionsEgress Amazon Elastic Compute Cloud EC2
Update-EC2SecurityGroupRuleIngressDescription UpdateSecurityGroupRuleDescriptionsIngress Amazon Elastic Compute Cloud EC2
```
Se conosci il nome del comando AWS Command Line Interface (AWS CLI), puoi utilizzare il `-AwsCliCommand` parametro e il nome del AWS CLI comando desiderato per ottenere il nome del cmdlet basato sulla stessa API. Ad esempio, per ottenere il nome del cmdlet che corrisponde alla chiamata di `authorize-security-group-ingress` AWS CLI comando nel EC2 servizio Amazon, esegui il comando seguente:
```
PS > Get-AWSCmdletName -AwsCliCommand "aws ec2 authorize-security-group-ingress"
CmdletName ServiceOperation ServiceName CmdletNounPrefix
---------- ---------------- ----------- ----------------
Grant-EC2SecurityGroupIngress AuthorizeSecurityGroupIngress Amazon Elastic Compute Cloud EC2
```
Il `Get-AWSCmdletName` cmdlet necessita solo del nome del AWS CLI comando sufficiente per identificare il servizio e l'API. AWS
Per ottenere un elenco di tutti i cmdlet presenti in Tools for PowerShell Core, eseguire il PowerShell `Get-Command` cmdlet, come illustrato nell'esempio seguente.
```
PS > Get-Command -Module AWSPowerShell.NetCore
```
Puoi eseguire lo stesso comando con `-Module AWSPowerShell` per visualizzare i cmdlet negli AWS Tools for Windows PowerShell.
Il cmdlet `Get-Command` genera l'elenco di cmdlet in ordine alfabetico. Si noti che per impostazione predefinita l'elenco è ordinato per PowerShell verbo, anziché per sostantivo. PowerShell
Per ordinare i risultati in base al servizio, esegui il comando seguente.
```
PS > Get-Command -Module AWSPowerShell.NetCore | Sort-Object Noun,Verb
```
Per filtrare i cmdlet restituiti dal cmdlet, reindirizzate l'`Get-Command`output al cmdlet. PowerShell `Select-String` Ad esempio, per visualizzare il set di cmdlet che funzionano con le regioni, esegui il comando seguente: AWS
```
PS > Get-Command -Module AWSPowerShell.NetCore | Select-String region
Clear-DefaultAWSRegion
Copy-HSM2BackupToRegion
Get-AWSRegion
Get-DefaultAWSRegion
Get-EC2Region
Get-LSRegionList
Get-RDSSourceRegion
Set-DefaultAWSRegion
```
È inoltre possibile trovare i cmdlet per un servizio specifico filtrando per il prefisso del servizio dei sostantivi del cmdlet. Per visualizzare l'elenco dei prefissi del servizio disponibili, esegui `Get-AWSPowerShellVersion -ListServiceVersionInfo`. L'esempio seguente restituisce cmdlet che supportano il servizio Amazon CloudWatch Events.
```
PS > Get-Command -Module AWSPowerShell -Noun CWE*
CommandType Name Version Source
----------- ---- ------- ------
Cmdlet Add-CWEResourceTag 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Disable-CWEEventSource 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Disable-CWERule 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Enable-CWEEventSource 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Enable-CWERule 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Get-CWEEventBus 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Get-CWEEventBusList 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Get-CWEEventSource 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Get-CWEEventSourceList 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Get-CWEPartnerEventSource 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Get-CWEPartnerEventSourceAccountList 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Get-CWEPartnerEventSourceList 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Get-CWEResourceTag 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Get-CWERule 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Get-CWERuleDetail 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Get-CWERuleNamesByTarget 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Get-CWETargetsByRule 3.3.563.1 AWSPowerShell.NetCore
Cmdlet New-CWEEventBus 3.3.563.1 AWSPowerShell.NetCore
Cmdlet New-CWEPartnerEventSource 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Remove-CWEEventBus 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Remove-CWEPartnerEventSource 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Remove-CWEPermission 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Remove-CWEResourceTag 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Remove-CWERule 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Remove-CWETarget 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Test-CWEEventPattern 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Write-CWEEvent 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Write-CWEPartnerEvent 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Write-CWEPermission 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Write-CWERule 3.3.563.1 AWSPowerShell.NetCore
Cmdlet Write-CWETarget 3.3.563.1 AWSPowerShell.NetCore
```
## Nomi dei cmdlet e degli alias
I cmdlet inclusi in AWS Strumenti per PowerShell for each service si basano sui metodi forniti dall' AWS SDK per il servizio. Tuttavia, a causa delle convenzioni PowerShell di denominazione obbligatorie, il nome di un cmdlet potrebbe essere diverso dal nome della chiamata API o del metodo su cui è basato. Ad esempio, il `Get-EC2Instance` cmdlet si basa sul metodo Amazon EC2`DescribeInstances`.
In alcuni casi, il nome del cmdlet può essere simile a un nome del metodo, ma potrebbe effettivamente eseguire una funzione differente. Ad esempio, il metodo Amazon S3`GetObject` recupera un oggetto Amazon S3. Tuttavia, il cmdlet `Get-S3Object` restituisce le *informazioni* su un oggetto Amazon S3 anziché l'oggetto stesso.
```
PS > Get-S3Object -BucketName text-content -Key aws-tech-docs
ETag : "df000002a0fe0000f3c000004EXAMPLE"
BucketName : aws-tech-docs
Key : javascript/frameset.js
LastModified : 6/13/2011 1:24:18 PM
Owner : Amazon.S3.Model.Owner
Size : 512
StorageClass : STANDARD
```
Per ottenere un oggetto S3 con AWS Strumenti per PowerShell, esegui il cmdlet: `Read-S3Object`
```
PS > Read-S3Object -BucketName text-content -Key text-object.txt -file c:\tmp\text-object-download.text
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a--- 11/5/2012 7:29 PM 20622 text-object-download.text
```
**Nota**
Il cmdlet help per un AWS cmdlet fornisce il nome dell'API AWS SDK su cui è basato il cmdlet.
[Per ulteriori informazioni sui verbi standard e sui relativi significati, PowerShell vedere Verbi approvati per i comandi. PowerShell ](https://learn.microsoft.com/en-us/powershell/scripting/developer/cmdlet/approved-verbs-for-windows-powershell-commands)
Tutti i AWS cmdlet che utilizzano il `Remove` verbo, e il `Stop-EC2Instance` cmdlet quando si aggiunge il `-Terminate` parametro, richiedono una conferma prima di procedere. Per ignorare la conferma, aggiungere il parametro `-Force` per il comando.
**Importante**
AWS i cmdlet non supportano lo switch. `-WhatIf`
### Alias
L'installazione di AWS Strumenti per PowerShell installa un file di alias che contiene alias per molti cmdlet. AWS Questi alias potrebbero risultare più intuitivi dei nomi dei cmdlet. Ad esempio, i nomi dei servizi e i nomi dei metodi AWS SDK sostituiscono PowerShell verbi e sostantivi in alcuni alias. Un esempio è l'alias `EC2-DescribeInstances`.
Altri alias utilizzano verbi che, sebbene non seguano le PowerShell convenzioni standard, possono essere più descrittivi dell'operazione effettiva. Ad esempio, il file alias associa l'alias `Get-S3Content` al cmdlet `Read-S3Object`.
```
PS > Set-Alias -Name Get-S3Content -Value Read-S3Object
```
Il file aliases si trova nella directory di installazione. AWS Strumenti per PowerShell Per caricare gli alias nell'ambiente, eseguire il file *dot-source*. Il seguente è un esempio basato su Windows.
```
PS > . "C:\Program Files (x86)\AWS Tools\PowerShell\AWSPowershell\AWSAliases.ps1"
```
Per una shell Linux o macOS, potrebbe essere simile a questo:
```
. ~/.local/share/powershell/Modules/AWSPowerShell.NetCore/3.3.563.1/AWSAliases.ps1
```
Per mostrare tutti gli AWS Strumenti per PowerShell alias, esegui il comando seguente. Questo comando utilizza l'`?`alias per il PowerShell `Where-Object` cmdlet e la `Source` proprietà per filtrare solo gli alias che provengono dal modulo. `AWSPowerShell.NetCore`
```
PS > Get-Alias | ? Source -like "AWSPowerShell.NetCore"
CommandType Name Version Source
----------- ---- ------- ------
Alias Add-ASInstances 3.3.343.0 AWSPowerShell
Alias Add-CTTag 3.3.343.0 AWSPowerShell
Alias Add-DPTags 3.3.343.0 AWSPowerShell
Alias Add-DSIpRoutes 3.3.343.0 AWSPowerShell
Alias Add-ELBTags 3.3.343.0 AWSPowerShell
Alias Add-EMRTag 3.3.343.0 AWSPowerShell
Alias Add-ESTag 3.3.343.0 AWSPowerShell
Alias Add-MLTag 3.3.343.0 AWSPowerShell
Alias Clear-AWSCredentials 3.3.343.0 AWSPowerShell
Alias Clear-AWSDefaults 3.3.343.0 AWSPowerShell
Alias Dismount-ASInstances 3.3.343.0 AWSPowerShell
Alias Edit-EC2Hosts 3.3.343.0 AWSPowerShell
Alias Edit-RSClusterIamRoles 3.3.343.0 AWSPowerShell
Alias Enable-ORGAllFeatures 3.3.343.0 AWSPowerShell
Alias Find-CTEvents 3.3.343.0 AWSPowerShell
Alias Get-ASACases 3.3.343.0 AWSPowerShell
Alias Get-ASAccountLimits 3.3.343.0 AWSPowerShell
Alias Get-ASACommunications 3.3.343.0 AWSPowerShell
Alias Get-ASAServices 3.3.343.0 AWSPowerShell
Alias Get-ASASeverityLevels 3.3.343.0 AWSPowerShell
Alias Get-ASATrustedAdvisorCheckRefreshStatuses 3.3.343.0 AWSPowerShell
Alias Get-ASATrustedAdvisorChecks 3.3.343.0 AWSPowerShell
Alias Get-ASATrustedAdvisorCheckSummaries 3.3.343.0 AWSPowerShell
Alias Get-ASLifecycleHooks 3.3.343.0 AWSPowerShell
Alias Get-ASLifecycleHookTypes 3.3.343.0 AWSPowerShell
Alias Get-AWSCredentials 3.3.343.0 AWSPowerShell
Alias Get-CDApplications 3.3.343.0 AWSPowerShell
Alias Get-CDDeployments 3.3.343.0 AWSPowerShell
Alias Get-CFCloudFrontOriginAccessIdentities 3.3.343.0 AWSPowerShell
Alias Get-CFDistributions 3.3.343.0 AWSPowerShell
Alias Get-CFGConfigRules 3.3.343.0 AWSPowerShell
Alias Get-CFGConfigurationRecorders 3.3.343.0 AWSPowerShell
Alias Get-CFGDeliveryChannels 3.3.343.0 AWSPowerShell
Alias Get-CFInvalidations 3.3.343.0 AWSPowerShell
Alias Get-CFNAccountLimits 3.3.343.0 AWSPowerShell
Alias Get-CFNStackEvents 3.3.343.0 AWSPowerShell
...
```
Per aggiungere alias personalizzati a questo file, potrebbe essere necessario aumentare il valore della [variabile di PowerShell `$MaximumAliasCount` preferenza a un valore superiore a 5500](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_preference_variables?view=powershell-6). Il valore predefinito è 4096; è possibile aumentarlo a un massimo di 32768. Per farlo, eseguire il comando seguente.
```
PS > $MaximumAliasCount = 32768
```
Per verificare che la modifica abbia avuto successo, inserire il nome della variabile per visualizzarne il valore corrente.
```
PS > $MaximumAliasCount
32768
```
# Pipeline, output e iterazione in AWS Strumenti per PowerShell
## Pipeline
PowerShell incoraggia gli utenti a connettere i cmdlet in [pipeline](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_pipelines) che indirizzano l'output di un cmdlet all'input del successivo. L'esempio seguente mostra questo comportamento quando si utilizza. AWS Strumenti per PowerShell Il comando ottiene e quindi arresta tutte le EC2 istanze Amazon nella regione predefinita corrente.
```
PS > Get-EC2Instance | Stop-EC2Instance
```
## Output del cmdlet
Per supportare meglio il pipelining, alcuni dati delle risposte di AWS SDK per .NET potrebbero essere eliminati per impostazione predefinita. L'output dei AWS Strumenti per PowerShell cmdlet non viene rimodellato per includere la risposta del servizio e le istanze dei risultati come `Note` proprietà dell'oggetto di raccolta emesso. Invece, per le chiamate che emettono una singola raccolta come output, la raccolta viene ora enumerata nella pipeline. PowerShell Ciò significa che i dati della risposta e dei risultati dell'SDK non possono esistere nella pipeline perché non esiste un oggetto di raccolta contenitore a cui possano essere allegati.
Sebbene la maggior parte degli utenti probabilmente non abbia bisogno di questi dati, possono essere utili per scopi diagnostici perché è possibile vedere esattamente cosa è stato inviato e ricevuto dalle chiamate di AWS servizio sottostanti effettuate dal cmdlet. I cmdlet possono utilizzare il `-Select *` parametro e l'argomento per restituire l'intera risposta del servizio.
Per illustrare come è possibile restituire tutti i dati di una risposta, si considerino gli esempi seguenti.
Il primo esempio restituisce semplicemente un elenco di bucket Amazon S3. Questo è il comportamento che segue di default.
```
PS > Get-S3Bucket
CreationDate BucketName
------------ ----------
9/22/2023 10:54:35 PM amzn-s3-demo-bucket1
9/22/2023 11:04:37 AM amzn-s3-demo-bucket2
9/22/2023 12:54:34 PM amzn-s3-demo-bucket3
```
Il secondo esempio restituisce un oggetto di AWS SDK per .NET risposta. Poiché `-Select *` è stato specificato, l'output include l'intera risposta API, che contiene la raccolta di bucket nella `Buckets` proprietà. In questo esempio, il `Format-List` cmdlet non è strettamente necessario, ma è presente per garantire la visualizzazione di tutte le proprietà.
```
PS > Get-S3Bucket -Select * | Format-List
LoggedAt : 10/1/2023 9:45:52 AM
Buckets : {amzn-s3-demo-bucket1, amzn-s3-demo-bucket2,
amzn-s3-demo-bucket3}
Owner : Amazon.S3.Model.Owner
ContinuationToken :
ResponseMetadata : Amazon.Runtime.ResponseMetadata
ContentLength : 0
HttpStatusCode : OK
```
## Iterazione tramite dati paginati
Le sezioni seguenti descrivono i vari tipi di iterazione possibili.
### Iterazione automatica
Per i servizi APIs che impongono un numero massimo predefinito di oggetti restituiti per una determinata chiamata o che supportano set di risultati paginabili, la maggior parte dei cmdlet implementa l'iterazione automatica, che abilita il comportamento predefinito di "». page-to-completion In questo scenario, un cmdlet effettua tutte le chiamate necessarie per conto dell'utente per restituire il set di dati completo alla pipeline.
Nell'esempio seguente, che utilizza il [Get-S3Object](https://docs.aws.amazon.com/powershell/v5/reference/index.html?page=Get-S3Object.html&tocid=Get-S3Object)cmdlet, la `$result` variabile contiene `S3Object` istanze per ogni chiave in un bucket chiamato`amzn-s3-demo-bucket1`, che è potenzialmente un set di dati molto grande.
```
PS > $result = Get-S3Object -BucketName amzn-s3-demo-bucket1
```
L'esempio seguente riduce il numero di risultati per ogni pagina durante l'iterazione automatica dal valore predefinito di 1000 a 500. L'esempio esegue il doppio delle chiamate di iterazione automatiche perché per ogni chiamata viene restituito solo la metà dei risultati.
```
PS > $result = Get-S3Object -BucketName amzn-s3-demo-bucket1 -MaxKey 500
```
### Disabilita l'iterazione automatica
Se desideri che gli strumenti PowerShell restituiscano solo la prima pagina di dati, puoi aggiungere il `-NoAutoIteration` parametro per evitare che vengano restituite pagine di dati aggiuntive.
L'esempio seguente utilizza i `-MaxKey` parametri `-NoAutoIteration` and per limitare il numero di `S3Object` istanze restituite a non più delle prime 500 trovate nel bucket.
```
PS > $result = Get-S3Object -BucketName amzn-s3-demo-bucket1 -MaxKey 500 -NoAutoIteration
```
Per determinare se sono disponibili più dati ma non sono stati restituiti, utilizzate il `-Select *` parametro e l'argomento e verificate se è presente un valore nella proprietà del token successivo.
L'esempio seguente restituisce `$true` se ci sono più di 500 oggetti nel bucket e `$false` altro.
```
PS > $result = Get-S3Object -BucketName amzn-s3-demo-bucket1 -MaxKey 500 -NoAutoIteration -Select *
PS > $null -eq $result.NextMarker
```
**Nota**
I nomi della proprietà di risposta del token successivo e del parametro del cmdlet variano tra i cmdlet. Per i dettagli, fare riferimento alla documentazione di aiuto per ogni cmdlet.
### Iterazione manuale
L'esempio seguente restituisce tutti gli oggetti S3 da un bucket utilizzando un ciclo [do](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_do), che valuta la condizione dopo ogni iterazione. Il `do` ciclo esegue iterazioni fino a quando non `Get-S3Object` viene impostato `$result.NextMarker` su`$null`, a indicare che non rimangono più dati paginati. L'output del loop viene assegnato alla `$s3Objects` variabile.
```
$s3Objects = do
{
$splatParams = @{
BucketName = 'amzn-s3-demo-bucket1'
MaxKey = 500
Marker = $result.NextMarker
NoAutoIteration = $true
Select = '*'
}
$result = Get-S3Object @splatParams
$result.S3Objects
}
while ($null -ne $result.NextMarker)
```
Questo esempio utilizza lo PowerShell [splatting](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_splatting) per evitare una lunga riga di codice causata dalla dichiarazione di parametri e argomenti in linea.
# Ulteriori informazioni su utenti e ruoli
Per eseguire Strumenti per PowerShell i comandi su AWS, è necessario disporre di una combinazione di utenti, set di autorizzazioni e ruoli di servizio appropriata per le proprie attività.
Gli utenti, i set di autorizzazioni e i ruoli di servizio specifici creati e il modo in cui li utilizzi dipenderanno dai tuoi requisiti. Di seguito sono riportate alcune informazioni aggiuntive sul motivo per cui potrebbero essere utilizzati e su come crearli.
## Utenti e set di autorizzazioni
Sebbene sia possibile utilizzare un account utente IAM con credenziali a lungo termine per accedere ai servizi AWS , questa non è più una best practice e dovrebbe essere evitata. Anche durante lo sviluppo, è consigliabile creare utenti e set di autorizzazioni AWS IAM Identity Center e utilizzare credenziali temporanee fornite da una fonte di identità.
Per lo sviluppo, puoi utilizzare l'utente che hai creato o assegnato in [Autenticazione con AWS](creds-idc.md). Se disponi Console di gestione AWS delle autorizzazioni appropriate, puoi anche creare diversi set di autorizzazioni con il privilegio minimo per quell'utente o creare nuovi utenti specificamente per progetti di sviluppo, fornendo set di autorizzazioni con il privilegio minimo. L'eventuale operazione scelta dipenderà dalle circostanze.
*Per ulteriori informazioni su questi utenti e set di autorizzazioni e su come crearli, consulta [Autenticazione e accesso](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) nella Guida di *riferimento agli strumenti AWS SDKs e Guida [introduttiva](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html) nella Guida* per l'utente.AWS IAM Identity Center *
## Ruoli di servizio
È possibile impostare un ruolo AWS di servizio per accedere ai AWS servizi per conto degli utenti. Questo tipo di accesso è appropriato se più persone eseguiranno l'applicazione in remoto, ad esempio su un' EC2 istanza Amazon che hai creato per questo scopo.
Il processo di creazione di un ruolo di servizio varia a seconda della situazione, ma è essenzialmente simile a quanto indicato di seguito.
1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Selezionare **Roles (Ruoli)**, quindi selezionare **Create role (Crea ruolo)**.
1. Scegli **AWS il servizio**, trova e seleziona **EC2**(ad esempio), quindi scegli il caso **EC2**d'uso (ad esempio).
1. Scegli **Avanti** e seleziona le [politiche appropriate](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) per i AWS servizi che l'applicazione utilizzerà.
**avvertimento**
***NON*** scegliete la **AdministratorAccess**politica perché tale politica consente le autorizzazioni di lettura e scrittura per quasi tutto il contenuto del vostro account.
1. Scegli **Next (Successivo)**. Immetti un valore in **Nome ruolo** e in **Descrizione** e quindi immetti qualsiasi altro tag desiderato.
Puoi trovare informazioni sui tag in [Controlling access using AWS resource tags](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html) nella [IAM User Guide](https://docs.aws.amazon.com/IAM/latest/UserGuide/).
1. Scegliere **Crea ruolo**.
Per ulteriori informazioni di alto livello sui ruoli IAM, consulta [Identità IAM (utenti, gruppi di utenti e ruoli)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html#id_iam-roles) nella [Guida per l'utente di IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/). Per informazioni dettagliate sui ruoli, consulta l'argomento [Ruoli IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).
# Uso delle credenziali legacy
Negli argomenti di questa sezione vengono fornite informazioni sull'utilizzo di credenziali a lungo termine o a breve termine senza utilizzare AWS IAM Identity Center.
**avvertimento**
Per evitare rischi per la sicurezza, non utilizzare gli utenti IAM per l’autenticazione quando sviluppi software creato ad hoc o lavori con dati reali. Utilizza invece la federazione con un provider di identità come [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html).
**Nota**
Le informazioni contenute in questi argomenti si riferiscono a scenari in cui è necessario ottenere e gestire manualmente le credenziali a breve o lungo termine. Per ulteriori informazioni sulle credenziali a breve e lungo termine, consulta [Altri modi di autenticazione nella Guida](https://docs.aws.amazon.com/sdkref/latest/guide/access-users.html) di *riferimento AWS SDKs e agli strumenti*.
Per le migliori pratiche di sicurezza, utilizzare AWS IAM Identity Center, come descritto in. [Autenticazione con AWS](creds-idc.md)
## Avvertenze e linee guida importanti per le credenziali
**Avvertenze per le credenziali**
+ ***NON*** utilizzate le credenziali root del vostro account per accedere alle AWS risorse. Queste credenziali forniscono un accesso illimitato all’account e sono difficili da revocare.
+ ***NON*** inserire chiavi di accesso letterali o informazioni sulle credenziali nei comandi o negli script. In caso contrario, si corre il rischio di esporre accidentalmente le proprie credenziali.
+ Tieni presente che tutte le credenziali memorizzate nel AWS `credentials` file condiviso vengono archiviate in testo non crittografato.
**Linee guida aggiuntive per la gestione sicura delle credenziali**
[Per una discussione generale su come gestire in modo sicuro le credenziali, consulta AWS le credenziali di sicurezza nella sezione [Credenziali AWS di sicurezza e le [best practice [Riferimenti generali di AWS](https://docs.aws.amazon.com/general/latest/gr/)e i casi d'uso di sicurezza](https://docs.aws.amazon.com/IAM/latest/UserGuide/IAMBestPracticesAndUseCases.html) nella IAM](https://docs.aws.amazon.com/general/latest/gr/Welcome.html#aws-security-credentials) User Guide.](https://docs.aws.amazon.com/IAM/latest/UserGuide/) Considera inoltre quanto segue:
+ Crea utenti aggiuntivi, come gli utenti in IAM Identity Center, e utilizza le loro credenziali invece di utilizzare le credenziali dell'utente root AWS . Le credenziali per altri utenti possono essere revocate, se necessario, o sono temporanee per natura. Inoltre, puoi applicare una policy a ciascun utente per consentire l'accesso solo a determinate risorse e azioni e quindi adottare autorizzazioni basate sul con privilegio minimo.
+ Usa [ruoli IAM](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) per le attività di Amazon Elastic Container Service (Amazon ECS).
+ Usa [ruoli IAM](shared-credentials-in-aws-powershell.md#shared-credentials-assume-role) per le applicazioni in esecuzione sulle istanze Amazon EC2.
**Topics**
+ [Avvertenze e linee guida importanti](#pstools-creds-warnings-and-guidelines)
+ [AWS Credenziali](specifying-your-aws-credentials.md)
+ [Credenziali condivise](shared-credentials-in-aws-powershell.md)
# Utilizzo delle AWS credenziali
Ogni AWS Strumenti per PowerShell comando deve includere un set di AWS credenziali, che vengono utilizzate per firmare crittograficamente la richiesta di servizio Web corrispondente. Puoi specificare le credenziali per comando, per sessione o per tutte le sessioni.
**avvertimento**
Per evitare rischi per la sicurezza, non utilizzare gli utenti IAM per l’autenticazione quando sviluppi software creato ad hoc o lavori con dati reali. Utilizza invece la federazione con un provider di identità come [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html).
**Nota**
Le informazioni contenute in questo argomento riguardano le circostanze in cui è necessario ottenere e gestire manualmente le credenziali a breve o lungo termine. *Per ulteriori informazioni sulle credenziali a breve e lungo termine, consulta [Altri modi di autenticazione nella and Tools](https://docs.aws.amazon.com/sdkref/latest/guide/access-users.html) Reference Guide.AWS SDKs *
Per le migliori pratiche di sicurezza, utilizzare AWS IAM Identity Center, come descritto in. [Autenticazione con AWS](creds-idc.md)
Come buona pratica, evitare di esporre le proprie credenziali, non utilizzare le credenziali letterali in un comando. Invece, creare un profilo per ogni set di credenziali che si desidera utilizzare e memorizzare il profilo in uno dei due archivi delle credenziali. Specificando il profilo corretto per nome nel comando, gli AWS Strumenti per PowerShell recuperano le credenziali associate. Per una discussione generale su come gestire in modo sicuro AWS le credenziali, vedere [Best Practices for Managing AWS Access Keys](https://docs.aws.amazon.com/general/latest/gr/aws-access-keys-best-practices.html) nel *Riferimenti generali di Amazon Web Services*.
**Nota**
È necessario un AWS account per ottenere le credenziali e utilizzare il. AWS Strumenti per PowerShell Per creare un AWS account, vedi [Guida introduttiva: Sei un utente principiante AWS](https://docs.aws.amazon.com/accounts/latest/reference/welcome-first-time-user.html)? nella *Guida di Gestione dell'account AWS riferimento*.
**Topics**
+ [Posizioni degli archivi per credenziali](#specifying-your-aws-credentials-store)
+ [Gestione dei profili](#managing-profiles)
+ [Specifica delle credenziali](#specifying-your-aws-credentials-use)
+ [Ordine di ricerca credenziali](#pstools-cred-provider-chain-legacy)
+ [Gestione delle credenziali in AWS Tools for PowerShell Core](#credential-handling-in-aws-tools-for-powershell-core)
## Posizioni degli archivi per credenziali
AWS Strumenti per PowerShell Possono utilizzare uno dei due archivi di credenziali:
+ L'archivio AWS SDK, che crittografa le credenziali e le archivia nella cartella home. In Windows, questo archivio si trova in: `C:\Users\username\AppData\Local\AWSToolkit\RegisteredAccounts.json`.
L'[AWS SDK per .NET](https://aws.amazon.com/sdk-for-net/) e il [Toolkit for Visual Studio](https://aws.amazon.com/visualstudio/) possono anche utilizzare l'archivio SDK AWS .
+ Il file delle credenziali condiviso, che si trova anche nella tua cartella home, ma archivia le credenziali come testo semplice.
Per impostazione predefinita, i file delle credenziali vengono archiviati qui:
+ Su Windows: `C:\Users\username\.aws\credentials`
+ Su Mac/Linux: `~/.aws/credentials`
Inoltre, AWS SDKs AWS Command Line Interface possono utilizzare il file delle credenziali. Se state eseguendo uno script al di fuori del contesto AWS utente, assicuratevi che il file contenente le credenziali venga copiato in una posizione in cui tutti gli account utente (sistema locale e utente) possano accedere alle vostre credenziali.
## Gestione dei profili
I profili consentono di fare riferimento a diversi set di credenziali con. AWS Strumenti per PowerShellÈ possibile utilizzare i AWS Strumenti per PowerShell cmdlet per gestire i profili nell'archivio SDK. AWS Inoltre, puoi gestire i profili nell'archivio SDK AWS utilizzando il [Toolkit for Visual Studio](https://docs.aws.amazon.com/AWSToolkitVS/latest/UserGuide/tkv_setup.html) o a livello di programmazione utilizzando l'[AWS SDK per .NET](https://aws.amazon.com/sdk-for-net/). Per istruzioni su come gestire i profili nel file delle credenziali, consulta [Best practice for](https://docs.aws.amazon.com/general/latest/gr/aws-access-keys-best-practices.html) Managing Access Keys. AWS
### Aggiunta di un nuovo profilo
Per aggiungere un nuovo profilo all'archivio AWS SDK, esegui il comando. `Set-AWSCredential` In questo modo la chiave di accesso e la chiave segreta vengono archiviate nel file delle credenziali predefinito sotto il nome del profilo specificato.
```
PS > Set-AWSCredential `
-AccessKey AKIA0123456787EXAMPLE `
-SecretKey wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY `
-StoreAs MyNewProfile
```
+ `-AccessKey` – L'ID chiave di accesso.
+ `-SecretKey` – La chiave segreta.
+ `-StoreAs`– Il nome del profilo, deve essere univoco. Per specificare il profilo predefinito, utilizza il nome `default`.
### Aggiornamento di un profilo
L'archivio AWS SDK deve essere gestito manualmente. Se successivamente si modificano le credenziali nel servizio, ad esempio utilizzando la [console IAM](https://console.aws.amazon.com/iam/home), eseguendo un comando con le credenziali archiviate in locale e questo ha esito negativo con il seguente messaggio di errore:
```
The Access Key Id you provided does not exist in our records.
```
È possibile aggiornare un profilo ripetendo il comando `Set-AWSCredential` per il profilo e passando a esso le nuove chiavi segrete e di accesso.
### Elenco dei profili
Puoi controllare l'elenco corrente dei nomi con il seguente comando. In questo esempio, un utente denominato Shirley ha accesso a tre profili che sono tutti archiviati nel file delle credenziali condiviso (`~/.aws/credentials`).
```
PS > Get-AWSCredential -ListProfileDetail
ProfileName StoreTypeName ProfileLocation
----------- ------------- ---------------
default SharedCredentialsFile /Users/shirley/.aws/credentials
production SharedCredentialsFile /Users/shirley/.aws/credentials
test SharedCredentialsFile /Users/shirley/.aws/credentials
```
### Rimozione di un profilo
Per rimuovere un profilo non più necessario, utilizza il comando seguente.
```
PS > Remove-AWSCredentialProfile -ProfileName an-old-profile-I-do-not-need
```
Il parametro `-ProfileName` specifica il profilo da eliminare.
Il comando obsoleto [Clear- AWSCredential](https://docs.aws.amazon.com/powershell/v5/reference/items/Clear-AWSCredential.html) è ancora disponibile per la compatibilità con le versioni precedenti, ma è preferito. `Remove-AWSCredentialProfile`
## Specifica delle credenziali
Esistono vari modi per specificare le credenziali. Il metodo preferito consiste nell'identificare un profilo anziché incorporare credenziali letterali nella riga di comando. AWS Strumenti per PowerShell [individua il profilo utilizzando un ordine di ricerca descritto in Ordine di ricerca delle credenziali.](#pstools-cred-provider-chain-legacy)
In Windows, AWS le credenziali archiviate nell'archivio AWS SDK sono crittografate con l'identità utente Windows che ha effettuato l'accesso. Non è possibile decrittografarle utilizzando un altro account o utilizzarle su un dispositivo diverso da quello in cui sono state create originariamente. Per eseguire attività che richiedono le credenziali di un altro utente, ad esempio un account utente utilizzato per eseguire un'attività pianificata, configura un profilo delle credenziali, come descritto nella sezione precedente, che è possibile utilizzare quando accedi al computer come tale utente. Accedi come utente che esegue attività per completare le fasi di configurazione delle credenziali e creare un profilo che funzioni per tale utente. Quindi disconnettiti e accedi di nuovo con le tue credenziali per configurare l'attività pianificata.
**Nota**
Utilizzare il parametro comune `-ProfileName` per specificare un profilo. Questo parametro è equivalente al `-StoredCredentials` parametro delle versioni precedenti. AWS Strumenti per PowerShell Per garantire la compatibilità con le versioni precedenti, `-StoredCredentials` è ancora supportato.
### Profilo predefinito (consigliato)
Tutti AWS SDKs gli strumenti di gestione sono in grado di trovare automaticamente le credenziali sul computer locale se le credenziali sono archiviate in un profilo denominato. `default` Ad esempio, se disponi di un profilo denominato `default` sul computer locale, non devi eseguire il cmdlet `Initialize-AWSDefaultConfiguration` o il cmdlet `Set-AWSCredential`. Gli strumenti utilizzano automaticamente i dati della chiave segreta e di accesso archiviati in quel profilo. Per usare una regione AWS diversa dalla regione predefinita (i risultati di `Get-DefaultAWSRegion`), puoi eseguire `Set-DefaultAWSRegion` e specificare una regione.
Se il profilo non è denominato `default`, ma si desidera utilizzarlo come profilo predefinito per la sessione corrente, eseguire `Set-AWSCredential` per impostare il profilo come predefinito.
Sebbene l'esecuzione `Initialize-AWSDefaultConfiguration` consenta di specificare un profilo predefinito per ogni PowerShell sessione, il cmdlet carica le credenziali dal profilo con nome personalizzato, ma sovrascrive il profilo con il profilo denominato. `default`
Ti consigliamo di non eseguire l'operazione `Initialize-AWSDefaultConfiguration` a meno che tu non stia eseguendo una PowerShell sessione su un'istanza Amazon EC2 che non è stata lanciata con un profilo di istanza e desideri configurare manualmente il profilo delle credenziali. Tieni presente che il profilo delle credenziali in questo caso non contiene le credenziali. Il profilo delle credenziali risultante dall'esecuzione di `Initialize-AWSDefaultConfiguration` su un'istanza EC2 non archivia direttamente le credenziali, ma punta invece ai metadati dell'istanza (che forniscono credenziali temporanee che ruotano automaticamente). Tuttavia, archivia la regione dell'istanza. Un altro scenario che potrebbe richiedere l'esecuzione di `Initialize-AWSDefaultConfiguration` si verifica se desideri eseguire una chiamata su una regione differente rispetto a quella in cui è in esecuzione l'istanza. L'esecuzione di questo comando sostituisce definitivamente la regione archiviata nei metadati delle istanze.
```
PS > Initialize-AWSDefaultConfiguration -ProfileName MyProfileName -Region us-west-2
```
**Nota**
Le credenziali predefinite sono incluse nell'archivio AWS SDK sotto il nome del profilo. `default` Il comando sovrascrive qualsiasi profilo esistente con lo stesso nome.
Se l'istanza EC2 è stata avviata con un profilo di istanza, ottiene PowerShell automaticamente AWS le credenziali e le informazioni sulla regione dal profilo dell'istanza. Non devi eseguire `Initialize-AWSDefaultConfiguration`. L'esecuzione del `Initialize-AWSDefaultConfiguration` cmdlet su un'istanza EC2 lanciata con un profilo di istanza non è necessaria, perché utilizza gli stessi dati del profilo di istanza già utilizzati per impostazione predefinita. PowerShell
### Profilo di sessione
Utilizzare `Set-AWSCredential` per specificare un profilo predefinito per una sessione particolare. Questo profilo sostituisce ogni profilo predefinito per la durata della sessione. Questo è consigliato se desideri utilizzare un profilo con nome personalizzato nella sessione anziché il profilo `default` corrente.
```
PS > Set-AWSCredential -ProfileName MyProfileName
```
**Nota**
Nelle versioni di Tools for Windows PowerShell precedenti alla 1.1, il `Set-AWSCredential` cmdlet non funzionava correttamente e sovrascriveva il profilo specificato da "». MyProfileName È consigliabile utilizzare una versione più recente degli strumenti per Windows. PowerShell
### Profilo di comando
Su singoli comandi, puoi aggiungere il parametro `-ProfileName` per specificare un profilo che si applica a un solo comando. Questo profilo sostituisce qualsiasi profilo predefinito o di sessione, come illustrato nell'esempio seguente.
```
PS > Get-EC2Instance -ProfileName MyProfileName
```
**Nota**
Quando specifichi un profilo predefinito o di sessione, puoi anche aggiungere un parametro `-Region` per sostituire una sessione predefinita o la regione della sessione. Per ulteriori informazioni, consulta [Specificare la AWS regione per AWS Strumenti per PowerShell](pstools-installing-specifying-region.md). L'esempio seguente specifica un profilo predefinito e la regione.
```
PS > Initialize-AWSDefaultConfiguration -ProfileName MyProfileName -Region us-west-2
```
Per impostazione predefinita, si presume che il file delle credenziali AWS condivise si trovi nella cartella home dell'utente (`C:\Users\username\.aws`su Windows o `~/.aws` su Linux). Per specificare un file delle credenziali in un percorso diverso, includi il parametro `-ProfileLocation` e specifica il percorso del file delle credenziali. L'esempio seguente specifica un file delle credenziali non predefinito per un determinato comando.
```
PS > Get-EC2Instance -ProfileName MyProfileName -ProfileLocation C:\aws_service_credentials\credentials
```
**Nota**
Se state eseguendo PowerShell uno script durante un periodo a cui normalmente non siete connessi, ad AWS esempio, state eseguendo uno PowerShell script come attività pianificata al di fuori del normale orario di lavoro, aggiungete il `-ProfileLocation` parametro quando specificate il profilo che desiderate utilizzare e impostate il valore sul percorso del file in cui sono memorizzate le credenziali. Per essere certi che AWS Strumenti per PowerShell lo script venga eseguito con le credenziali dell'account corrette, è necessario aggiungere il `-ProfileLocation` parametro ogni volta che lo script viene eseguito in un contesto o in un processo che non utilizza un AWS account. È anche possibile copiare il file delle credenziali in un percorso accessibile al sistema locale o ad altri account che lo script utilizza per eseguire le attività.
## Ordine di ricerca credenziali
Quando esegui un comando, AWS Strumenti per PowerShell cerca le credenziali nell'ordine seguente. Si interrompe quando trova le credenziali utilizzabili.
1. Credenziali letterali incorporate come parametri nella riga di comando.
Consigliamo di utilizzare i profili anziché inserire credenziali letterali nelle righe di comando.
1. Credenziali specificate dal parametro `-Credential`.
1. Un nome di profilo o una posizione del profilo che è stato specificato utilizzando il cmdlet [Set- AWSCredential](https://docs.aws.amazon.com/powershell/v5/reference/items/Set-AWSCredential.html).
+ Se si specifica solo un nome di profilo, il comando cerca il profilo specificato nell'archivio AWS SDK e, se non esiste, il profilo specificato dal file delle credenziali AWS condivise nella posizione predefinita.
+ Se specifichi solo una posizione del profilo, il comando cerca il profilo `default` dal file delle credenziali.
+ Se specifichi sia un nome sia un percorso, il comando cerca il profilo specificato nel file delle credenziali.
Se il profilo specificato o il percorso non è stato trovato, il comando genera un'eccezione. La ricerca procede nelle seguenti fasi solo se non hai specificato un profilo o una posizione.
1. Credenziali create dalle variabili di `AWS_SESSION_TOKEN` ambiente `AWS_ACCESS_KEY_ID``AWS_SECRET_ACCESS_KEY`, e se tutte e tre le variabili hanno un valore.
1. Il profilo delle credenziali con il nome specificato dalla variabile di `AWS_PROFILE` ambiente.
1. Il profilo predefinito nell'ordine seguente:
1. Il `default` profilo nell'archivio AWS SDK.
1. Il `default` profilo nel AWS `credentials` file condiviso.
1. Il `AWS PS Default` profilo nell'archivio AWS SDK.
1. Se il comando è in esecuzione su un'istanza Amazon EC2 configurata per l'utilizzo di un ruolo IAM, le credenziali temporanee dell'istanza EC2 a cui si accede dal profilo dell'istanza.
[Per ulteriori informazioni sull'utilizzo dei ruoli IAM per le istanze Amazon EC2, consulta [Granting access with a role nella Developer](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-hosm.html) Guide.AWS SDK per .NET](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/)
Se la ricerca ha esito negativo per individuare le credenziali specificate, il comando genera un'eccezione.
Per ulteriori informazioni sulle variabili di ambiente e sui profili di credenziali, consulta i seguenti argomenti nella [Guida di riferimento agli strumenti AWS SDKs e agli strumenti](https://docs.aws.amazon.com/sdkref/latest/guide/): variabili di [ambiente, elenco delle variabili](https://docs.aws.amazon.com/sdkref/latest/guide/environment-variables.html) [di ambiente](https://docs.aws.amazon.com/sdkref/latest/guide/settings-reference.html#EVarSettings) e file di configurazione e credenziali [condivisi](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html).
## Gestione delle credenziali in AWS Tools for PowerShell Core
I cmdlet AWS Tools for PowerShell Core accettano le chiavi di AWS accesso e segrete o i nomi dei profili di credenziali quando vengono eseguiti, in modo analogo a. AWS Tools for Windows PowerShell Quando vengono eseguiti su Windows, entrambi i moduli hanno accesso ai file di archivio delle credenziali AWS SDK per .NET (archiviati per ogni utente in `AppData\Local\AWSToolkit\RegisteredAccounts.json`).
Questo file memorizza le proprie chiavi in formato crittografato e non può essere utilizzato su un altro computer. È il primo file che AWS Strumenti per PowerShell cerca un profilo di credenziali, ed è anche il file in cui vengono archiviati i profili delle credenziali. AWS Strumenti per PowerShell [Per ulteriori informazioni sul file di archiviazione delle AWS SDK per .NET credenziali, vedere Configurazione delle credenziali. AWS](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-config-creds.html) Il PowerShell modulo Tools for Windows attualmente non supporta la scrittura di credenziali su altri file o posizioni.
Entrambi i moduli possono leggere i profili dal file di credenziali AWS condivise utilizzato da altri AWS SDKs e da. AWS CLI In Windows, la posizione predefinita per questo file è `C:\Users\\.aws\credentials`. Su piattaforme non Windows, questo file viene memorizzato in `~/.aws/credentials`. Il parametro `-ProfileLocation` può essere utilizzato per puntare a un nome di file non predefinito o a una posizione del file.
L'archivio di credenziali SDK contiene le credenziali in forma crittografata utilizzando la crittografia di Windows. APIs Queste non APIs sono disponibili su altre piattaforme, quindi il AWS Tools for PowerShell Core modulo utilizza esclusivamente il file di credenziali AWS condivise e supporta la scrittura di nuovi profili di credenziali nel file di credenziali condiviso.
**Gli script di esempio seguenti che utilizzano il `Set-AWSCredential` cmdlet mostrano le opzioni per la gestione dei profili di credenziali in Windows con Shell o Shell. AWSPower AWSPower** ** NetCore**moduli.
```
# Writes a new (or updates existing) profile with name "myProfileName"
# in the encrypted SDK store file
Set-AWSCredential -AccessKey akey -SecretKey skey -StoreAs myProfileName
# Checks the encrypted SDK credential store for the profile and then
# falls back to the shared credentials file in the default location
Set-AWSCredential -ProfileName myProfileName
# Bypasses the encrypted SDK credential store and attempts to load the
# profile from the ini-format credentials file "mycredentials" in the
# folder C:\MyCustomPath
Set-AWSCredential -ProfileName myProfileName -ProfileLocation C:\MyCustomPath\mycredentials
```
I seguenti esempi mostrano il comportamento della **AWSPowerShell. NetCore**modulo sui sistemi operativi Linux o macOS.
```
# Writes a new (or updates existing) profile with name "myProfileName"
# in the default shared credentials file ~/.aws/credentials
Set-AWSCredential -AccessKey akey -SecretKey skey -StoreAs myProfileName
# Writes a new (or updates existing) profile with name "myProfileName"
# into an ini-format credentials file "~/mycustompath/mycredentials"
Set-AWSCredential -AccessKey akey -SecretKey skey -StoreAs myProfileName -ProfileLocation ~/mycustompath/mycredentials
# Reads the default shared credential file looking for the profile "myProfileName"
Set-AWSCredential -ProfileName myProfileName
# Reads the specified credential file looking for the profile "myProfileName"
Set-AWSCredential -ProfileName myProfileName -ProfileLocation ~/mycustompath/mycredentials
```
# Credenziali condivise in AWS Strumenti per PowerShell
Gli strumenti per Windows PowerShell supportano l'uso del file di credenziali AWS condivise, in modo analogo a AWS CLI e altri. AWS SDKs Gli Strumenti per Windows PowerShell ora supportano la lettura e la scrittura e i profili di `basic` `assume role` credenziali sia nel file di credenziali.NET che nel file di credenziali AWS condiviso. `session` Questa funzionalità è abilitata da un nuovo namespace `Amazon.Runtime.CredentialManagement`.
**avvertimento**
Per evitare rischi per la sicurezza, non utilizzare gli utenti IAM per l’autenticazione quando sviluppi software creato ad hoc o lavori con dati reali. Utilizza invece la federazione con un provider di identità come [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html).
**Nota**
Le informazioni contenute in questo argomento riguardano le circostanze in cui è necessario ottenere e gestire manualmente le credenziali a breve o lungo termine. *Per ulteriori informazioni sulle credenziali a breve e lungo termine, consulta [Altri modi di autenticazione nella and Tools](https://docs.aws.amazon.com/sdkref/latest/guide/access-users.html) Reference Guide.AWS SDKs *
Per le migliori pratiche di sicurezza, utilizzare AWS IAM Identity Center, come descritto in. [Autenticazione con AWS](creds-idc.md)
[https://docs.aws.amazon.com/powershell/v5/reference/items/New-AWSCredential.html](https://docs.aws.amazon.com/powershell/v5/reference/items/New-AWSCredential.html) Nei cmdlet del servizio, puoi fare riferimento ai nuovi profili aggiungendo il parametro comune `-ProfileName`.
## Utilizzo di un ruolo IAM con AWS Strumenti per PowerShell
Il file di credenziali AWS condiviso consente tipi di accesso aggiuntivi. Ad esempio, puoi accedere alle tue AWS risorse utilizzando un ruolo IAM anziché le credenziali a lungo termine di un utente IAM. A tale scopo, devi disporre di un profilo standard con autorizzazioni per assumere il ruolo. Quando gli dici AWS Strumenti per PowerShell di utilizzare un profilo che ha specificato un ruolo, AWS Strumenti per PowerShell cerca il profilo identificato dal `SourceProfile` parametro. Tali credenziali vengono utilizzate per richiedere credenziali temporanee per il ruolo specificato dal parametro `RoleArn`. Puoi richiedere l'utilizzo di un dispositivo di autenticazione a più fattori (Multi-Factor Authentication (MFA)) o di un codice `ExternalId` quando terze parti assumono il ruolo.
****
| Nome parametro | Description |
| --- | --- |
| ExternalId | L'ID esterno definito dall'utente da utilizzare quando assume un ruolo, se richiesto dal ruolo. In genere, è necessario solo quando deleghi l'accesso al tuo account a terze parti. La terza parte deve includere il parametro ExternalId come parametro quando assume il ruolo assegnato. Per ulteriori informazioni, consulta [Come utilizzare un ID esterno per concedere l'accesso alle AWS risorse a terzi](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) nella Guida per l'*utente IAM*. |
| MfaSerial | Il numero seriale MFA da utilizzare quando assume un ruolo, se richiesto dal ruolo. Per ulteriori informazioni, consulta la sezione [Utilizzo dell'autenticazione a più fattori (MFA) in AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa.html) nella *Guida per l'utente IAM*. |
| RoleArn | L'ARN del ruolo da assumere per assumere le credenziali di ruolo. Per ulteriori informazioni sulla creazione e sull'utilizzo dei ruoli IAM, consulta la sezione relativa ai [ruoli IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) nella *Guida per l'utente IAM*. |
| SourceProfile | Il nome del profilo di origine da utilizzare assumendo credenziali di ruolo. Le credenziali trovate in questo profilo vengono utilizzate per assumere il ruolo specificato dal parametro `RoleArn`. |
### Configurazione dei profili per assumere un ruolo
Di seguito è riportato un esempio che mostra come configurare un profilo fonte che consente di assumere direttamente un ruolo IAM.
Il primo comando crea un profilo di origine a cui fa riferimento il profilo del ruolo. Il secondo comando crea il profilo che quel ruolo assumerà. Il terzo comando mostra le credenziali per il profilo del ruolo.
```
PS > Set-AWSCredential -StoreAs my_source_profile -AccessKey access_key_id -SecretKey secret_key
PS > Set-AWSCredential -StoreAs my_role_profile -SourceProfile my_source_profile -RoleArn arn:aws:iam::123456789012:role/role-i-want-to-assume
PS > Get-AWSCredential -ProfileName my_role_profile
SourceCredentials RoleArn RoleSessionName Options
----------------- ------- --------------- -------
Amazon.Runtime.BasicAWSCredentials arn:aws:iam::123456789012:role/role-i-want-to-assume aws-dotnet-sdk-session-636238288466144357 Amazon.Runtime.AssumeRoleAWSCredentialsOptions
```
Per utilizzare questo profilo di ruolo con i cmdlet di PowerShell servizio Tools for Windows, aggiungi il parametro `-ProfileName` common al comando per fare riferimento al profilo del ruolo. L'esempio seguente utilizza il profilo del ruolo definito nell'esempio precedente per accedere al [Get-S3Bucket](https://docs.aws.amazon.com/powershell/v5/reference/items/Get-S3Bucket.html)cmdlet. AWS Strumenti per PowerShell cerca le credenziali`my_source_profile`, utilizza tali credenziali per chiamare per `AssumeRole` conto dell'utente e quindi utilizza quelle credenziali di ruolo temporanee per chiamare. `Get-S3Bucket`
```
PS > Get-S3Bucket -ProfileName my_role_profile
CreationDate BucketName
------------ ----------
2/27/2017 8:57:53 AM 4ba3578c-f88f-4d8b-b95f-92a8858dac58-bucket1
2/27/2017 10:44:37 AM 2091a504-66a9-4d69-8981-aaef812a02c3-bucket2
```
## Utilizzo dei tipi di credenziali del profilo
Per impostare il tipo di credenziali del profilo, comprendere quali parametri forniscono le informazioni necessarie per il tipo di profilo.
****
| Tipo di credenziali | Parametri da utilizzare |
| --- | --- |
| **Di base** Queste sono le credenziali a lungo termine per un utente IAM | `-AccessKey` `-SecretKey` |
| **Sessione**: [Queste sono le credenziali a breve termine per un ruolo IAM recuperabili manualmente, ad esempio chiamando direttamente il cmdlet Use-. STSRole](https://docs.aws.amazon.com/powershell/v5/reference/items/Use-STSRole.html) | `-AccessKey` `-SecretKey` `-SessionToken` |
| **Ruolo**: Queste sono credenziali a breve termine per un ruolo IAM che gli AWS Strumenti per PowerShell recuperano per tuo conto. | `-SourceProfile` `-RoleArn` facoltativo: `-ExternalId` facoltativo: `-MfaSerial` |
## Il parametro comune `ProfileLocation`
È possibile utilizzare `-ProfileLocation` per scrivere nel file delle credenziali condivise e istruire un cmdlet per leggere il file delle credenziali. L'aggiunta del `-ProfileLocation` parametro controlla se Tools for Windows PowerShell utilizza il file di credenziali condiviso o il file di credenziali.NET. La tabella seguente descrive come funziona il parametro in Tools for Windows. PowerShell
****
| Valore posizione profilo | Comportamento della risoluzione del profilo |
| --- | --- |
| null (non impostato) o vuoto | In primo luogo, cerca il file delle credenziali .NET per un profilo con il nome specificato. Se il profilo non viene trovato, cerca nel file delle credenziali AWS condivise in`(user's home directory)\.aws\credentials`. |
| Il percorso di un file nel formato di file con credenziali AWS condivise | Cerca solo un profilo con uno specifico nome nel file specificato. |
### Salvare le credenziali in un file delle credenziali
Per scrivere e salvare le credenziali in uno dei due file delle credenziali, eseguire il cmdlet `Set-AWSCredential`. Gli esempi seguenti mostrano come fare: Il primo comando utilizza `Set-AWSCredential` con `-ProfileLocation` per aggiungere chiavi segrete e di accesso a un profilo specificato dal parametro `-ProfileName`. Nella seconda riga, eseguire il cmdlet [Get-Content](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.management/get-content) per visualizzare il contenuto del file delle credenziali.
```
PS > Set-AWSCredential -ProfileLocation C:\Users\auser\.aws\credentials -ProfileName basic_profile -AccessKey access_key2 -SecretKey secret_key2
PS > Get-Content C:\Users\auser\.aws\credentials
aws_access_key_id=access_key2
aws_secret_access_key=secret_key2
```
## Visualizzazione dei profili delle credenziali
Eseguire il AWSCredential cmdlet [Get-](https://docs.aws.amazon.com/powershell/v5/reference/items/Get-AWSCredential.html) e aggiungere il `-ListProfileDetail` parametro per restituire i tipi e le posizioni dei file delle credenziali e un elenco di nomi di profilo.
```
PS > Get-AWSCredential -ListProfileDetail
ProfileName StoreTypeName ProfileLocation
----------- ------------- ---------------
source_profile NetSDKCredentialsFile
assume_role_profile NetSDKCredentialsFile
basic_profile SharedCredentialsFile C:\Users\auser\.aws\credentials
```
## Rimozione dei profili delle credenziali
Per rimuovere i profili di credenziali, eseguire il nuovo cmdlet [Remove](https://docs.aws.amazon.com/powershell/v5/reference/items/Remove-AWSCredentialProfile.html) - Profile. AWSCredential [Clear- AWSCredential](https://docs.aws.amazon.com/powershell/v5/reference/items/Clear-AWSCredential.html) è obsoleto, ma è ancora disponibile per la compatibilità con le versioni precedenti.
## Note importanti
Solo [Initialize- AWSDefault Configuration](https://docs.aws.amazon.com/powershell/v5/reference/items/Initialize-AWSDefaultConfiguration.html), [New- e [Set- AWSCredential AWSCredential](https://docs.aws.amazon.com/powershell/v5/reference/items/Set-AWSCredential.html)](https://docs.aws.amazon.com/powershell/v5/reference/items/New-AWSCredential.html) supportano i parametri per i profili di ruolo. Non puoi specificare i parametri del ruolo direttamente in un comando come `Get-S3Bucket -SourceProfile source_profile_name -RoleArn arn:aws:iam::999999999999:role/role_name`. Ciò non funziona perché i cmdlet di servizio non supportano direttamente i parametri `SourceProfile` o `RoleArn`. Devi invece archiviare tali parametri in un profilo, quindi chiamare il comando con il parametro `-ProfileName`.