Version 5 (V5) von AWS -Tools für PowerShell wurde veröffentlicht\$1
Informationen zu wichtigen Änderungen und zur Migration Ihrer Anwendungen finden Sie im [Migrationsthema](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)
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Konfiguration und Verwendung des AWS -Tools für PowerShell
In einigen der Themen in diesem Abschnitt werden die Grundlagen der Verwendung der Tools für Windows beschrieben, PowerShell nachdem Sie [die Tools installiert und die Authentifizierung eingerichtet](pstools-getting-set-up.md) haben. Sie erklären beispielsweise, wie angegeben wird, für welche [AWS Region](pstools-installing-specifying-region.md) die Tools bei der Interaktion verwendet PowerShell werden sollen. AWS
Andere Themen in diesem Abschnitt enthalten Informationen zu erweiterten Möglichkeiten für die Konfiguration der Tools, Ihrer Umgebung und Ihrer Projekte.
**Topics**
+ [AWS Region](pstools-installing-specifying-region.md)
+ [Auflösung von Anmeldeinformationen und Profilen](creds-assign.md)
+ [Konfigurieren einer Verbundidentität](saml-pst.md)
+ [Beobachtbarkeit](observability.md)
+ [Cmdlet-Erkennung und -Aliasse](pstools-discovery-aliases.md)
+ [Pipelining, Ausgabe und Iteration](pstools-pipelines.md)
+ [Benutzer und Rollen](pstools-users-roles.md)
+ [Verwenden von Legacy-Anmeldeinformationen](pstools-cred-legacy.md)
# Geben Sie die AWS Region für AWS -Tools für PowerShell
Es gibt zwei Möglichkeiten, die AWS Region anzugeben, die bei der Ausführung von AWS -Tools für PowerShell Befehlen verwendet werden soll:
+ Verwenden Sie den allgemeinen Parameter `-Region` für einzelne Befehle.
+ Verwenden Sie den Befehl `Set-DefaultAWSRegion`, um eine Standardregion für alle Befehle festzulegen.
Viele AWS Cmdlets schlagen fehl, wenn die Tools für Windows nicht herausfinden PowerShell können, welche Region verwendet werden soll. Zu den Ausnahmen gehören Cmdlets für [Amazon S3](pstools-s3.md), Amazon SES und AWS Identity and Access Management, die automatisch standardmäßig einen globalen Endpunkt verwenden.
**Um die Region für einen einzelnen Befehl anzugeben AWS **
Fügen Sie den Parameter `-Region` zu Ihrem Befehl hinzu, zum Beispiel folgendermaßen.
```
PS > Get-EC2Image -Region us-west-2
```
**So legen Sie eine Standardregion für alle AWS CLI-Befehle in der aktuellen Sitzung fest**
Geben Sie in der PowerShell Befehlszeile den folgenden Befehl ein.
```
PS > Set-DefaultAWSRegion -Region us-west-2
```
**Anmerkung**
Diese Einstellung bleibt nur für die aktuelle Sitzung bestehen. Um die Einstellung auf alle Ihre PowerShell Sitzungen anzuwenden, fügen Sie diesen Befehl Ihrem PowerShell Profil hinzu, wie Sie es für den `Import-Module` Befehl getan haben.
**So zeigen Sie die aktuelle Standardregion für alle AWS CLI-Befehle an**
Geben Sie in der PowerShell Befehlszeile den folgenden Befehl ein.
```
PS > Get-DefaultAWSRegion
Region Name IsShellDefault
------ ---- --------------
us-west-2 US West (Oregon) True
```
**Um die aktuelle Standardregion für alle AWS CLI-Befehle zu löschen**
Geben Sie in der PowerShell Befehlszeile den folgenden Befehl ein.
```
PS > Clear-DefaultAWSRegion
```
**Um eine Liste aller verfügbaren AWS Regionen anzuzeigen**
Geben Sie in der PowerShell Befehlszeile den folgenden Befehl ein. Die dritte Spalte in der Beispielausgabe gibt an, welche Region die Standardeinstellung für Ihre aktuelle Sitzung ist.
```
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
...
```
**Anmerkung**
Einige Regionen werden möglicherweise unterstützt, sind jedoch nicht in den Ausgaben des Cmdlets `Get-AWSRegion` enthalten. Dies gilt beispielsweise manchmal für Regionen, die noch nicht global sind. Wenn Sie eine Region nicht angeben können, indem Sie den Parameter `-Region` zu einem Befehl hinzufügen, geben Sie die Region stattdessen in einem benutzerdefinierten Endpunkt an, wie im folgenden Abschnitt gezeigt.
## Angeben eines benutzerdefinierten oder nicht standardmäßigen Endpunkts
Geben Sie einen benutzerdefinierten Endpunkt als URL an, indem Sie Ihrem PowerShell Befehl Tools für Windows den `-EndpointUrl` gemeinsamen Parameter im folgenden Beispielformat hinzufügen.
```
PS > Some-AWS-PowerShellCmdlet -EndpointUrl "custom endpoint URL" -Other -Parameters
```
Im Folgenden finden Sie ein Beispiel für die Verwendung des `Get-EC2Instance`-Cmdlets. Der benutzerdefinierte Endpunkt ist in diesem Beispiel in `us-west-2` oder USA West (Oregon), aber Sie können auch jede andere unterstützte AWS -Region verwenden, einschließlich solcher Regionen, die nicht von `Get-AWSRegion` aufgezählt werden.
```
PS > Get-EC2Instance -EndpointUrl "https://service-custom-url.us-west-2.amazonaws.com" -InstanceID "i-0555a30a2000000e1"
```
## Zusätzliche Informationen
Weitere Informationen zu AWS Regionen finden Sie unter [AWS Region](https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html) im Referenzhandbuch *AWS SDKs und im Tools-Referenzhandbuch*.
# Auflösung von Anmeldeinformationen und Profilen
## Suchreihenfolge für Anmeldeinformationen
Wenn Sie einen Befehl ausführen, wird in der folgenden Reihenfolge nach Anmeldeinformationen AWS -Tools für PowerShell gesucht. Dieser Vorgang wird beendet, wenn verwendbare Anmeldeinformationen gefunden wurden.
1. Literale Anmeldeinformationen, die als Parameter in der Befehlszeile eingebettet sind.
Wir empfehlen dringend, Profile zu verwenden, anstatt literale Anmeldeinformationen in die Befehlszeile einzugeben.
1. Mit dem Parameter `-Credential` angegebene Anmeldeinformationen.
1. Ein Profilname oder ein Profilspeicherort, der mit dem AWSCredential Cmdlet [Set-](https://docs.aws.amazon.com/powershell/v5/reference/items/Set-AWSCredential.html) angegeben wurde.
+ Wenn Sie nur einen Profilnamen angeben, sucht der Befehl im AWS SDK-Speicher nach dem angegebenen Profil und, falls dieses nicht vorhanden ist, nach dem angegebenen Profil aus der Datei mit den AWS gemeinsamen Anmeldeinformationen am Standardspeicherort.
+ Wenn Sie nur einen Profilspeicherort angeben, wird bei Ausführung des Befehls das `default`-Profil in dieser Datei mit Anmeldeinformationen gesucht.
+ Wenn Sie sowohl einen Namen als auch einen Speicherort angeben, wird bei Ausführung des Befehls nach dem angegebenen Profil in dieser Datei mit Anmeldeinformationen gesucht.
Wenn der angegebene Profilname oder Speicherort nicht gefunden wird, löst der Befehl eine Ausnahme aus. Die folgenden Suchschritte werden nur durchgeführt, wenn Sie kein Profil und keinen Speicherort angegeben haben.
1. Anmeldeinformationen, die aus den `AWS_SESSION_TOKEN` Umgebungsvariablen `AWS_ACCESS_KEY_ID``AWS_SECRET_ACCESS_KEY`, und erstellt werden, wenn alle drei Variablen einen Wert haben.
1. Das Anmeldeinformationsprofil mit dem in der `AWS_PROFILE` Umgebungsvariablen angegebenen Namen.
1. Das Standardprofil in der folgenden Reihenfolge:
1. Das `default` Profil im AWS SDK-Speicher.
1. Das `default` Profil in der gemeinsam genutzten AWS `credentials` Datei.
1. Das `AWS PS Default` Profil im AWS SDK-Speicher.
1. Wenn der Befehl auf einer EC2 Amazon-Instance ausgeführt wird, die für die Verwendung einer IAM-Rolle konfiguriert ist, werden die temporären Anmeldeinformationen der EC2 Instance über das Instance-Profil abgerufen.
Weitere Informationen zur Verwendung von IAM-Rollen für EC2 Amazon-Instances finden Sie unter [Granting access with a role](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-hosm.html) im [AWS SDK für .NET Developer Guide](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/).
Wenn die angegebenen Anmeldeinformationen im Rahmen dieser Suche nicht gefunden werden, löst der Befehl eine Ausnahme aus.
Weitere Informationen zu Umgebungsvariablen und Profilen mit Anmeldeinformationen finden Sie in den folgenden Themen im [Referenzhandbuch zu Tools](https://docs.aws.amazon.com/sdkref/latest/guide/): [Umgebungsvariablen](https://docs.aws.amazon.com/sdkref/latest/guide/environment-variables.html), [Liste der Umgebungsvariablen](https://docs.aws.amazon.com/sdkref/latest/guide/settings-reference.html#EVarSettings) und [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html).AWS SDKs
# Konfigurieren Sie die föderierte Identität mit dem AWS -Tools für PowerShell
Damit Benutzer in Ihrer Organisation auf AWS Ressourcen zugreifen können, müssen Sie eine standardmäßige und wiederholbare Authentifizierungsmethode konfigurieren, um die Sicherheit, Überprüfbarkeit und Einhaltung von Vorschriften zu gewährleisten und die Rollen- und Kontotrennung zu unterstützen. Es ist zwar üblich, Benutzern Zugriff zu gewähren AWS APIs, aber ohne föderierten API-Zugriff müssten Sie auch AWS Identity and Access Management (IAM-) Benutzer erstellen, was den Zweck der Verbundnutzung zunichte macht. In diesem Thema wird die SAML-Unterstützung (Security Assertion Markup Language) in der Lösung, die AWS -Tools für PowerShell Ihren Verbundzugriff erleichtert, beschrieben.
Mit der SAML-Unterstützung AWS -Tools für PowerShell können Sie Ihren Benutzern Verbundzugriff auf Dienste gewähren. AWS SAML ist ein XML-basiertes, offenes Standardformat für die Übertragung von Benutzerauthentifizierungs- und Autorisierungsdaten zwischen Diensten, insbesondere zwischen einem Identitätsanbieter (wie [Active Directory Federation Services](https://learn.microsoft.com/en-us/windows-server/identity/ad-fs/ad-fs-overview)) und einem Dienstanbieter (z. B.). AWS Weitere Informationen zu SAML und ihrer Funktionsweise finden Sie unter [SAML](https://en.wikipedia.org/wiki/Security_Assertion_Markup_Language) auf Wikipedia und unter [SAML Technical Specifications](https://www.oasis-open.org/standard/saml/) auf der Website der Organization for the Advancement of Structured Information Standards (OASIS). Die SAML-Unterstützung in AWS -Tools für PowerShell ist mit SAML 2.0 kompatibel.
## Voraussetzungen
Folgendes ist erforderlich, bevor Sie die SAML-Unterstützung erstmals nutzen können.
+ Eine Verbundidentitätslösung, die richtig in das AWS -Konto integriert ist und den Konsolenzugriff nur mit den Anmeldeinformationen der Organisation ermöglicht. Weitere Informationen dazu, wie Sie dies speziell für Active Directory Federation Services tun können, finden Sie unter [About SAML 2.0 Federation](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html) im *IAM-Benutzerhandbuch* und im Blogbeitrag [Enabling Federation to AWS Using Windows Active Directory, AD FS,](https://aws.amazon.com/blogs/security/enabling-federation-to-aws-using-windows-active-directory-adfs-and-saml-2-0/) and SAML 2.0. Der Blogbeitrag befasst sich zwar mit AD FS 2.0, die Schritte für AD FS 3.0 sind aber identisch.
+ Version 3.1.31.0 oder neuer der auf Ihrer lokalen Workstation installierten Version. AWS -Tools für PowerShell
## So erhält ein Identity-Federated-Benutzer Verbundzugriff auf den Dienst AWS APIs
Im folgenden Prozess wird allgemein beschrieben, wie ein Active Directory-Benutzer (AD) über AD FS zusammengeführt wird, um Zugriff auf Ressourcen zu erhalten. AWS
![\[Diagram showing federated user access flow to AWS resources via AD FS and Security Token Service.\]](http://docs.aws.amazon.com/de_de/powershell/v5/userguide/images/powershell_ADFSauth_using_vsd.png)
1. Der Client auf dem Computer des verbundenen Benutzers authentifiziert sich gegen AD FS.
1. Wenn die Authentifizierung erfolgreich ist, sendet AD FS eine SAML-Assertion an den Benutzer.
1. Der Client des Benutzers sendet die SAML-Assertion als Teil einer SAML-Verbundanforderung an den AWS -Security-Token-Service (STS).
1. STS gibt eine SAML-Antwort zurück, die AWS temporäre Anmeldeinformationen für eine Rolle enthält, die der Benutzer übernehmen kann.
1. Der Benutzer greift auf den AWS Dienst zu, APIs indem er diese temporären Anmeldeinformationen in die Anfrage von einbezieht. AWS -Tools für PowerShell
## So funktioniert der SAML-Support in der AWS -Tools für PowerShell
In diesem Abschnitt wird beschrieben, wie AWS -Tools für PowerShell Cmdlets die Konfiguration eines SAML-basierten Identitätsverbunds für Benutzer ermöglichen.
![\[Diagram showing SAML-based federation flow between organization, AD FS, AWS, and service APIs.\]](http://docs.aws.amazon.com/de_de/powershell/v5/userguide/images/Powershell_SamlAuth_using_vsd.png)
1. AWS -Tools für PowerShell authentifiziert sich bei AD FS mithilfe der aktuellen Anmeldeinformationen des Windows-Benutzers oder interaktiv, wenn der Benutzer versucht, ein Cmdlet auszuführen, für dessen Aufruf Anmeldeinformationen erforderlich sind. AWS
1. AD FS authentifiziert den Benutzer.
1. AD FS generiert eine SAML 2.0-Authentifizierungsantwort, die eine Assertion enthält. Der Zweck der Assertion besteht darin, den Benutzer zu identifizieren und Informationen über ihn bereitzustellen. AWS -Tools für PowerShell extrahiert die Liste der autorisierten Rollen des Benutzers aus der SAML-Assertion.
1. AWS -Tools für PowerShell leitet die SAML-Anfrage, einschließlich der Amazon Resource Names (ARN) der angeforderten Rolle, durch den `AssumeRoleWithSAMLRequest` API-Aufruf an STS weiter.
1. Wenn die SAML-Anforderung gültig ist, gibt STS eine Antwort mit den Werten AWS , `AccessKeyId`, `SecretAccessKey` und `SessionToken` zurück. Diese Anmeldeinformationen gelten für 3.600 Sekunden (1 Stunde).
1. Der Benutzer verfügt jetzt über gültige Anmeldeinformationen, um mit allen AWS Diensten zu arbeiten APIs , auf die die Rolle des Benutzers zugreifen darf. AWS -Tools für PowerShell wendet diese Anmeldeinformationen automatisch für alle nachfolgenden AWS API-Aufrufe an und erneuert sie automatisch, wenn sie ablaufen.
**Anmerkung**
Wenn die Anmeldeinformationen ablaufen und neue Anmeldeinformationen benötigt werden, nehmen die AWS -Tools für PowerShell die erneute Authentifizierung bei AD FS automatisch vor und rufen neue Anmeldeinformationen für eine weitere Stunde ab. Für Benutzer eines Kontos, das mit einer Domäne verknüpft ist, erfolgt dieser Prozess vollständig transparent. Fordert Benutzer bei Konten, die nicht in eine Domäne eingebunden sind, AWS -Tools für PowerShell zur Eingabe ihrer Anmeldeinformationen auf, bevor sie sich erneut authentifizieren können.
## So verwenden Sie die SAML-Konfigurations-Cmdlets PowerShell
AWS -Tools für PowerShell enthält zwei neue Cmdlets, die SAML-Unterstützung bieten.
+ `Set-AWSSamlEndpoint` konfiguriert den AD FS-Endpunkt, weist dem Endpunkt einen Anzeigenamen zu und beschreibt optional den Authentifizierungstyp des Endpunkts.
+ `Set-AWSSamlRoleProfile` erstellt und bearbeitet ein Benutzerkontoprofil, das Sie einem AD FS-Endpunkt zuordnen können, der durch Angeben des Anzeigenamens identifiziert wird, den Sie für das Cmdlet `Set-AWSSamlEndpoint` bereitgestellt haben. Jedes Rollenprofil ist einer einzelnen Rolle zugeordnet, zu deren Ausführung ein Benutzer berechtigt ist.
Wie bei Profilen mit AWS Anmeldeinformationen weisen Sie dem Rollenprofil einen benutzerfreundlichen Namen zu. Sie können denselben Anzeigenamen für das `Set-AWSCredential` Cmdlet oder als Wert des `-ProfileName` Parameters für jedes Cmdlet verwenden, das den Dienst aufruft. AWS APIs
Öffnen Sie eine neue Sitzung. AWS -Tools für PowerShell Wenn Sie PowerShell 3.0 oder neuer ausführen, wird das AWS -Tools für PowerShell Modul automatisch importiert, wenn Sie eines seiner Cmdlets ausführen. Wenn Sie PowerShell 2.0 ausführen, müssen Sie das Modul manuell importieren, indem Sie das Cmdlet ``Import-Module`` ausführen, wie im folgenden Beispiel gezeigt.
```
PS > Import-Module "C:\Program Files (x86)\AWS Tools\PowerShell\AWSPowerShell\AWSPowerShell.psd1"
```
### Ausführen der Cmdlets `Set-AWSSamlEndpoint` und `Set-AWSSamlRoleProfile`
1. Konfigurieren Sie zunächst die Endpunkt-Einstellungen für das AD FS-System. Die einfachste Möglichkeit besteht darin, den Endpunkt wie in diesem Schritt gezeigt in einer Variablen zu speichern. Achten Sie darauf, das Platzhalterkonto IDs und den AD FS-Hostnamen durch Ihr eigenes Konto und den AD FS-Hostnamen zu ersetzen. IDs Geben Sie den AD FS-Hostnamen im Parameter `Endpoint` an.
```
PS > $endpoint = "https://adfs.example.com/adfs/ls/IdpInitiatedSignOn.aspx?loginToRp=urn:amazon:webservices"
```
1. Führen Sie zum Erstellen des Endpunkts das Cmdlet `Set-AWSSamlEndpoint` aus. Geben Sie dabei den richtigen Wert für den Parameter `AuthenticationType` an. Gültige Werte sind `Basic`, `Digest`, `Kerberos`, `Negotiate` und `NTLM`. Wenn Sie diesen Parameter nicht angeben, lautet der Standardwert `Kerberos`.
```
PS > $epName = Set-AWSSamlEndpoint -Endpoint $endpoint -StoreAs ADFS-Demo -AuthenticationType NTLM
```
Das Cmdlet gibt den Anzeigenamen zurück, den Sie mit dem Parameter `-StoreAs` zugewiesen haben, sodass Sie ihn nutzen können, wenn Sie in der nächsten Zeile `Set-AWSSamlRoleProfile` ausführen.
1. Führen Sie jetzt das Cmdlet `Set-AWSSamlRoleProfile` aus, um den AD FS-Identitätsanbieter zu authentifizieren und die Rollen (in der SAML-Assertion) abzurufen, die der Benutzer ausführen darf.
Das Cmdlet `Set-AWSSamlRoleProfile` verwendet die zurückgegebenen Rollen, um den Benutzer zum Auswählen einer Rolle aufzufordern, die dem angegebenen Profil zugeordnet werden soll, oder um zu validieren, ob die Rollendaten in den angegebenen Parametern vorhanden sind (andernfalls wird der Benutzer zur Auswahl aufgefordert). Wenn der Benutzer nur für eine Rolle autorisiert ist, ordnet das Cmdlet diese Rolle dem Profil automatisch zu, ohne den Benutzer zur Auswahl aufzufordern. Es ist nicht erforderlich, Anmeldeinformationen anzugeben, um ein Profil für die Domänenverknüpfung einzurichten.
```
PS > Set-AWSSamlRoleProfile -StoreAs SAMLDemoProfile -EndpointName $epName
```
Alternativ können Sie für non-domain-joined Konten Active Directory-Anmeldeinformationen angeben und dann eine AWS Rolle auswählen, auf die der Benutzer Zugriff hat, wie in der folgenden Zeile gezeigt. Dies ist nützlich, wenn Sie unterschiedliche Active Directory-Benutzerkonten verwenden, um die Rollen in der Organisation zu differenzieren (z. B. Administrationsfunktionen).
```
PS > $credential = Get-Credential -Message "Enter the domain credentials for the endpoint"
PS > Set-AWSSamlRoleProfile -EndpointName $epName -NetworkCredential $credential -StoreAs SAMLDemoProfile
```
1. In jedem Fall fordert das Cmdlet `Set-AWSSamlRoleProfile` Sie auf, die Rolle zu wählen, die im Profil gespeichert werden soll. Das folgende Beispiel zeigt zwei verfügbare Rollen: `ADFS-Dev` und `ADFS-Production`. Die IAM-Rollen werden vom AD-FS-Administrator mit Ihren AD-Anmeldeinformationen verknüpft.
```
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"):
```
Alternativ können Sie eine Rolle ohne Eingabeaufforderung angeben, indem Sie die Parameter `RoleARN`, `PrincipalARN` und optional `NetworkCredential` eingeben. Wenn die angegebene Rolle nicht in der von der Authentifizierung zurückgegebenen Assertion aufgeführt ist, wird der Benutzer aufgefordert, eine der verfügbaren Rollen auszuwählen.
```
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. Sie können Profile für alle Rollen mit nur einem Befehl erstellen, indem Sie den Parameter `StoreAllRoles` hinzufügen (siehe den folgenden Code). Beachten Sie, dass der Rollenname als Profilname verwendet wird.
```
PS > Set-AWSSamlRoleProfile -EndpointName $epName -StoreAllRoles
ADFS-Dev
ADFS-Production
```
### So verwenden Sie Rollenprofile, um Cmdlets auszuführen, für die Anmeldeinformationen erforderlich sind AWS
Um Cmdlets auszuführen, für die AWS Anmeldeinformationen erforderlich sind, können Sie Rollenprofile verwenden, die in der Datei mit den AWS gemeinsam genutzten Anmeldeinformationen definiert sind. Geben Sie den Namen eines Rollenprofils an `Set-AWSCredential` (oder als Wert für einen beliebigen `ProfileName` Parameter in AWS -Tools für PowerShell), um automatisch temporäre AWS Anmeldeinformationen für die im Profil beschriebene Rolle abzurufen.
Obwohl Sie jeweils nur ein Rollenprofil verwenden, können Sie in einer Shell-Sitzung zwischen Profilen umschalten. Das Cmdlet `Set-AWSCredential` authentifiziert nicht und ruft keine Anmeldeinformationen ab, wenn Sie es selbstständig ausführen. Das Cmdlet zeichnet auf, dass Sie ein bestimmtes Rollenprofil verwenden möchten. Bis Sie ein Cmdlet ausführen, das AWS -Anmeldeinformationen benötigt, erfolgt keine Authentifizierung und es werden keine Anmeldeinformationen angefordert.
Sie können jetzt die temporären AWS Anmeldeinformationen, die Sie mit dem `SAMLDemoProfile` Profil erhalten haben, für die Arbeit mit dem AWS Dienst verwenden APIs. Die folgenden Abschnitte zeigen Beispiele zur Verwendung von Rollenprofilen.
### Beispiel 1: Festlegen einer Standardrolle mit `Set-AWSCredential`
In diesem Beispiel wird eine Standardrolle für eine AWS -Tools für PowerShell Sitzung mithilfe von festgelegt`Set-AWSCredential`. Anschließend können Sie Cmdlets ausführen, die Anmeldeinformationen benötigen und von der angegebenen Rolle autorisiert sind. In diesem Beispiel werden alle Amazon-Elastic-Compute-Cloud-Instances in der Region USA West (Oregon) aufgelistet, die dem im `Set-AWSCredential`-Cmdlet angegeben Profil zugeordnet sind.
```
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}
```
### Beispiel 2: Rollenprofile während einer PowerShell Sitzung ändern
In diesem Beispiel werden alle verfügbaren Amazon S3 S3-Buckets im AWS Konto der Rolle aufgeführt, die dem `SAMLDemoProfile` Profil zugeordnet ist. Das Beispiel zeigt, dass Sie, obwohl Sie zu Beginn Ihrer AWS -Tools für PowerShell Sitzung möglicherweise ein anderes Profil verwendet haben, Profile ändern können, indem Sie mit Cmdlets, die ihn unterstützen, einen anderen Wert für den `-ProfileName` Parameter angeben. Dies ist eine häufige Aufgabe für Administratoren, die Amazon S3 über die PowerShell Befehlszeile verwalten.
```
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
```
Beachten Sie, dass das Cmdlet `Get-S3Bucket` den Namen des Profils angibt, das durch Ausführen des Cmdlets `Set-AWSSamlRoleProfile` erstellt wurde. Dieser Befehl kann nützlich sein, wenn Sie früher in der Sitzung ein Rollenprofil festgelegt haben (z. B. durch Ausführen des Cmdlets `Set-AWSCredential`) und ein anderes Rollenprofil für das Cmdlet `Get-S3Bucket` verwenden wollen. Der Profilmanager macht dem Cmdlet `Get-S3Bucket` temporäre Anmeldeinformationen verfügbar.
Obwohl die Anmeldeinformationen nach einer Stunde ablaufen (ein von STS durchgesetztes Limit), aktualisieren die AWS -Tools für PowerShell die Anmeldeinformationen automatisch, indem eine neue SAML-Assertion angefordert wird, wenn die Tools feststellen, dass die aktuellen Anmeldeinformationen abgelaufen sind.
Für Benutzer mit Domänenverknüpfung erfolgt dieser Prozess ohne Unterbrechung, weil die Windows-Identität des aktuellen Benutzers für die Authentifizierung verwendet wird. AWS -Tools für PowerShell Zeigt für non-domain-joined Benutzerkonten eine Eingabeaufforderung mit der Aufforderung PowerShell zur Eingabe des Benutzerpassworts an. Der Benutzer gibt Anmeldeinformationen ein, die für die erneute Authentifizierung des Benutzers und zum Abrufen einer neuen Assertion verwendet werden.
### Beispiel 3: Ermitteln der Instances in einer Region
Das folgende Beispiel listet alle Amazon-EC2-Instances in der Region Asien-Pazifik (Sydney) auf, die mit dem vom Profil `ADFS-Production` verwendeten Konto verknüpft sind. Mit diesem Befehl können Sie alle Amazon-EC2-Instances in einer Region zurückgeben.
```
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
```
## Weiterführende Lektüre
Allgemeine Informationen zur Implementierung des API-Verbundzugriffs finden Sie unter [So implementieren Sie eine allgemeine Lösung für den API/CLI Verbundzugriff mithilfe von](https://aws.amazon.com/blogs/security/how-to-implement-a-general-solution-for-federated-apicli-access-using-saml-2-0/) SAML 2.0.
[Wenn Sie Fragen oder Kommentare zum Support haben, besuchen Sie die AWS Entwicklerforen für [PowerShell Scripting](https://forums.aws.amazon.com/forum.jspa?forumID=149) oder .NET-Entwicklung.](https://forums.aws.amazon.com/forum.jspa?forumID=61)
# Beobachtbarkeit
Beobachtbarkeit ist das Ausmaß, in dem der aktuelle Zustand eines Systems aus den ausgegebenen Daten abgeleitet werden kann. Die ausgegebenen Daten werden allgemein als Telemetrie bezeichnet. [Weitere Informationen zur Telemetrie bei der Nutzung von AWS Diensten finden Sie unter [Observability im AWS SDK für .NET Developer](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/observability.html) Guide.](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/)
Der folgende Code zeigt ein Beispiel dafür, wie Observability in der aktiviert werden kann. AWS -Tools für 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'
```
# Cmdlet-Erkennung und -Aliasse
In diesem Abschnitt erfahren Sie, wie Sie Dienste auflisten AWS -Tools für PowerShell, die von der unterstützt werden, die Gruppe von Cmdlets anzeigen, die AWS -Tools für PowerShell von zur Unterstützung dieser Dienste bereitgestellt werden, und wie Sie alternative Cmdlet-Namen (auch Aliase genannt) für den Zugriff auf diese Dienste finden.
## Cmdlet-Erkennung
Alle AWS Dienstvorgänge (oder APIs) sind im API-Referenzhandbuch für jeden Dienst dokumentiert. Siehe zum Beispiel die [IAM-API-Referenz](https://docs.aws.amazon.com/IAM/latest/APIReference/). In den meisten Fällen besteht eine one-to-one Entsprechung zwischen einer AWS Service-API und einem AWS PowerShell Cmdlet. Um den Cmdlet-Namen abzurufen, der einem AWS Dienst-API-Namen entspricht, führen Sie das AWS `Get-AWSCmdletName` Cmdlet mit dem `-ApiOperation` Parameter und dem Dienst-API-Namen aus. AWS Um beispielsweise alle möglichen Cmdlet-Namen abzurufen, die auf einer verfügbaren `DescribeInstances` AWS Service-API basieren, führen Sie den folgenden Befehl aus:
```
PS > Get-AWSCmdletName -ApiOperation DescribeInstances
CmdletName ServiceOperation ServiceName CmdletNounPrefix
---------- ---------------- ----------- ----------------
Get-EC2Instance DescribeInstances Amazon Elastic Compute Cloud EC2
Get-GMLInstance DescribeInstances Amazon GameLift Service GML
```
Der Parameter `-ApiOperation` ist der Standardparameter, sodass Sie den Parameternamen auslassen können. Das folgende Beispiel entspricht dem vorherigen:
```
PS > Get-AWSCmdletName DescribeInstances
```
Wenn Sie sowohl die Namen der API als auch des Dienstes kennen, können Sie den `-Service` Parameter zusammen mit dem Substantivpräfix des Cmdlets oder einem Teil des Dienstnamens angeben. AWS Das Nominalpräfix des Cmdlets für Amazon EC2 lautet beispielsweise. `EC2` Führen Sie einen der folgenden Befehle aus, um den Cmdlet-Namen abzurufen, der der `DescribeInstances` API im EC2 Amazon-Service entspricht. Sie sind alle Ergebnis in der gleichen Ausgabe:
```
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
```
Bei den Parameterwerten für diese Befehle wird die Groß- und Kleinschreibung berücksichtigt.
Wenn Sie den Namen der gewünschten AWS Service-API oder des Dienstes nicht kennen, können Sie den `-ApiOperation` Parameter zusammen mit dem abzugleichenden Muster und dem `-MatchWithRegex` Parameter verwenden. AWS Um beispielsweise alle verfügbaren Cmdlet-Namen zu ermitteln, die `SecurityGroup` enthalten, führen Sie den folgenden Befehl aus:
```
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
```
Wenn Sie den Namen des Dienstes, aber nicht die AWS AWS Service-API kennen, geben Sie sowohl den `-MatchWithRegex` Parameter als auch den `-Service` Parameter an, um die Suche auf einen einzelnen Dienst einzugrenzen. Um beispielsweise alle Cmdlet-Namen abzurufen, die nur den EC2 Amazon-Service enthalten`SecurityGroup`, führen Sie den folgenden Befehl aus
```
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
```
Wenn Sie den Namen des Befehls AWS Command Line Interface (AWS CLI) kennen, können Sie den `-AwsCliCommand` Parameter und den gewünschten AWS CLI Befehlsnamen verwenden, um den Namen des Cmdlets abzurufen, das auf derselben API basiert. Um beispielsweise den Namen des Cmdlets abzurufen, der dem `authorize-security-group-ingress` AWS CLI Befehlsaufruf im EC2 Amazon-Service entspricht, führen Sie den folgenden Befehl aus:
```
PS > Get-AWSCmdletName -AwsCliCommand "aws ec2 authorize-security-group-ingress"
CmdletName ServiceOperation ServiceName CmdletNounPrefix
---------- ---------------- ----------- ----------------
Grant-EC2SecurityGroupIngress AuthorizeSecurityGroupIngress Amazon Elastic Compute Cloud EC2
```
Das `Get-AWSCmdletName` Cmdlet benötigt nur genügend AWS CLI Befehlsnamen, um den Service und die API zu identifizieren. AWS
Um eine Liste aller Cmdlets in den Tools for PowerShell Core abzurufen, führen Sie das PowerShell `Get-Command` Cmdlet aus, wie im folgenden Beispiel gezeigt.
```
PS > Get-Command -Module AWSPowerShell.NetCore
```
Sie können denselben Befehl mit `-Module AWSPowerShell` ausführen, um die Cmdlets in den AWS Tools for Windows PowerShell anzuzeigen.
Das Cmdlet `Get-Command` generiert die Liste der Cmdlets in alphabetischer Reihenfolge. Beachten Sie, dass die Liste standardmäßig nach PowerShell Verb und nicht nach Substantiv sortiert ist. PowerShell
Um die Ergebnisse stattdessen nach Service zu sortieren, führen Sie den folgenden Befehl aus:
```
PS > Get-Command -Module AWSPowerShell.NetCore | Sort-Object Noun,Verb
```
Um die vom Cmdlet zurückgegebenen Cmdlets zu filtern, leiten Sie die Ausgabe über die Pipeline an das `Get-Command` Cmdlet weiter. PowerShell `Select-String` Um beispielsweise den Satz von Cmdlets anzuzeigen, die mit Regionen funktionieren, führen Sie den folgenden Befehl aus: 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
```
Sie können Cmdlets für einen bestimmten Service auch ermitteln, indem Sie nach dem Service-Präfix des Cmdlet-Substantivs filtern. Führen Sie `Get-AWSPowerShellVersion -ListServiceVersionInfo` aus, um die Liste der verfügbaren Servicepräfixe anzuzeigen. Im folgenden Beispiel werden Cmdlets zurückgegeben, die den Amazon CloudWatch Events-Service unterstützen.
```
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
```
## Cmdlet-Namen und -Aliasse
Die Cmdlets AWS -Tools für PowerShell für jeden Service basieren auf den Methoden, die vom AWS SDK für den Service bereitgestellt werden. Aufgrund der PowerShell verbindlichen Benennungskonventionen kann sich der Name eines Cmdlets jedoch vom Namen des API-Aufrufs oder der Methode unterscheiden, auf der es basiert. Das `Get-EC2Instance` Cmdlet basiert beispielsweise auf der EC2 `DescribeInstances` Amazon-Methode.
In manchen Fällen kann der Cmdlet-Name dem Namen einer Methode ähneln, obwohl es eine andere Funktion ausführt. Die Amazon-S3-Methode `GetObject` ruft beispielsweise ein Amazon-S3-Objekt ab. Das Cmdlet `Get-S3Object` gibt jedoch *Informationen* zu einem Amazon-S3-Objekt zurück, nicht das Objekt selbst.
```
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
```
Um ein S3-Objekt mit dem abzurufen AWS -Tools für PowerShell, führen Sie das folgende Cmdlet aus: `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
```
**Anmerkung**
Die Cmdlet-Hilfe für ein AWS Cmdlet enthält den Namen der AWS SDK-API, auf der das Cmdlet basiert.
[Weitere Informationen zu PowerShell Standardverben und ihren Bedeutungen finden Sie unter Zulässige Verben für Befehle. PowerShell ](https://learn.microsoft.com/en-us/powershell/scripting/developer/cmdlet/approved-verbs-for-windows-powershell-commands)
Alle AWS Cmdlets, die das `Remove` Verb verwenden — und das `Stop-EC2Instance` Cmdlet, wenn Sie den `-Terminate` Parameter hinzufügen — werden zur Bestätigung aufgefordert, bevor der Vorgang fortgesetzt wird. Mit dem Parameter `-Force` können Sie die Bestätigung umgehen.
**Wichtig**
AWS Cmdlets unterstützen den Switch nicht. `-WhatIf`
### Aliasnamen
Beim Setup von AWS -Tools für PowerShell wird eine Aliasdatei installiert, die Aliase für viele der Cmdlets enthält. AWS Diese Aliasnamen sind möglicherweise intuitiver als die Cmdlet-Namen. Beispielsweise ersetzen Dienstnamen und AWS SDK-Methodennamen PowerShell Verben und Substantive in einigen Aliasnamen. Ein Beispiel ist der Alias `EC2-DescribeInstances`.
Andere Aliase verwenden Verben, die zwar nicht den PowerShell Standardkonventionen entsprechen, die eigentliche Operation aber aussagekräftiger beschreiben können. Die Aliasdatei ordnet beispielsweise den Alias `Get-S3Content` dem Cmdlet `Read-S3Object` zu.
```
PS > Set-Alias -Name Get-S3Content -Value Read-S3Object
```
Die Aliasdatei befindet sich im Installationsverzeichnis. AWS -Tools für PowerShell Um die Aliasnamen in die Umgebung zu laden, geben Sie die Datei in der *Punkt-Quelle*-Schreibweise an. Im Folgenden finden Sie ein Windows-basiertes Beispiel.
```
PS > . "C:\Program Files (x86)\AWS Tools\PowerShell\AWSPowershell\AWSAliases.ps1"
```
Für eine Linux- oder macOS-Shell könnte es folgendermaßen aussehen:
```
. ~/.local/share/powershell/Modules/AWSPowerShell.NetCore/3.3.563.1/AWSAliases.ps1
```
Führen Sie den folgenden Befehl aus, um alle AWS -Tools für PowerShell Aliase anzuzeigen. Dieser Befehl verwendet den `?` Alias für das PowerShell `Where-Object` Cmdlet und die `Source` Eigenschaft, um nur nach Aliasen zu filtern, die aus dem Modul stammen. `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
...
```
Um dieser Datei eigene Aliase hinzuzufügen, müssen Sie möglicherweise den Wert der `$MaximumAliasCount` [Präferenzvariablen](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_preference_variables?view=powershell-6) auf einen Wert über PowerShell 5500 erhöhen. Der Standardwert ist 4096. Sie können ihn auf maximal 32.768 erhöhen. Führen Sie dazu den folgenden Befehl aus.
```
PS > $MaximumAliasCount = 32768
```
Um zu überprüfen, ob Ihre Änderung erfolgreich war, geben Sie den Variablennamen ein, um den aktuellen Wert anzuzeigen.
```
PS > $MaximumAliasCount
32768
```
# Pipelining, Ausgabe und Iteration in der AWS -Tools für PowerShell
## Pipelining
PowerShell ermutigt Benutzer, Cmdlets mit [Pipelines](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_pipelines) zu verbinden, die die Ausgabe eines Cmdlets in die Eingabe des nächsten weiterleiten. Das folgende Beispiel zeigt dieses Verhalten bei der Verwendung von. AWS -Tools für PowerShell Der Befehl ruft alle EC2 Amazon-Instances in der aktuellen Standardregion ab und stoppt sie dann.
```
PS > Get-EC2Instance | Stop-EC2Instance
```
## Cmdlet-Ausgabe
Um das Pipelining besser zu unterstützen, werden einige Daten aus den Antworten von AWS SDK für .NET möglicherweise standardmäßig verworfen. Die Ausgabe von AWS -Tools für PowerShell Cmdlets wird nicht so umgestaltet, dass sie die Dienstantwort und die Ergebnisinstanzen als `Note` Eigenschaften für das ausgegebene Auflistungsobjekt enthält. Stattdessen wird bei Aufrufen, die eine einzelne Sammlung als Ausgabe ausgeben, die Sammlung nun in der Pipeline aufgezählt. PowerShell Das bedeutet, dass die SDK-Antwort und die Ergebnisdaten nicht in der Pipeline existieren können, da es kein enthaltendes Sammlungsobjekt gibt, an das sie angehängt werden können.
Obwohl die meisten Benutzer diese Daten wahrscheinlich nicht benötigen, können sie für Diagnosezwecke nützlich sein, da Sie genau sehen können, was an die zugrunde liegenden AWS Serviceanfragen gesendet und von ihnen empfangen wurde, die vom Cmdlet getätigt wurden. Cmdlets können den `-Select *` Parameter und das Argument verwenden, um die gesamte Dienstantwort zurückzugeben.
Sehen Sie sich die folgenden Beispiele an, um zu veranschaulichen, wie alle Daten aus einer Antwort zurückgegeben werden können.
Das erste Beispiel gibt einfach eine Liste von Amazon S3 S3-Buckets zurück. Dies ist das Standardverhalten.
```
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
```
Das zweite Beispiel gibt ein AWS SDK für .NET Antwortobjekt zurück. Da angegeben `-Select *` wurde, umfasst die Ausgabe die gesamte API-Antwort, die die Sammlung von Buckets in der `Buckets` Eigenschaft enthält. In diesem Beispiel ist das `Format-List` Cmdlet nicht unbedingt erforderlich, aber es ist vorhanden, um sicherzustellen, dass alle Eigenschaften angezeigt werden.
```
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
```
## Iteration durch seitenweise gespeicherte Daten
In den folgenden Abschnitten werden verschiedene Arten von Iterationen beschrieben, die möglich sind.
### Automatische Iteration
Für Dienste APIs , die eine standardmäßige maximale Anzahl zurückgegebener Objekte für einen bestimmten Aufruf festlegen oder Ergebnismengen unterstützen, implementieren die meisten Cmdlets die automatische Iteration, wodurch das Standardverhalten von "" aktiviert wird. page-to-completion In diesem Szenario führt ein Cmdlet in Ihrem Namen so viele Aufrufe durch, wie erforderlich sind, um den vollständigen Datensatz an die Pipeline zurückzugeben.
Im folgenden Beispiel, in dem das [Get-S3Object](https://docs.aws.amazon.com/powershell/v5/reference/index.html?page=Get-S3Object.html&tocid=Get-S3Object)Cmdlet verwendet wird, enthält die `$result` Variable `S3Object` Instanzen für jeden Schlüssel in einem aufgerufenen Bucket`amzn-s3-demo-bucket1`, bei dem es sich möglicherweise um einen sehr großen Datensatz handelt.
```
PS > $result = Get-S3Object -BucketName amzn-s3-demo-bucket1
```
Im folgenden Beispiel wird die Anzahl der Ergebnisse für jede Seite während der automatischen Iteration vom Standardwert 1000 auf 500 reduziert. In diesem Beispiel werden doppelt so viele automatische Iterationsaufrufe ausgeführt, da bei jedem Aufruf nur halb so viele Ergebnisse zurückgegeben werden.
```
PS > $result = Get-S3Object -BucketName amzn-s3-demo-bucket1 -MaxKey 500
```
### Automatische Iteration deaktivieren
Wenn Sie möchten, dass die Tools für PowerShell nur die erste Datenseite zurückgeben, können Sie den `-NoAutoIteration` Parameter hinzufügen, um zu verhindern, dass weitere Datenseiten zurückgegeben werden.
Das folgende Beispiel verwendet die `-MaxKey` Parameter `-NoAutoIteration` und, um die Anzahl der zurückgegebenen `S3Object` Instanzen auf nicht mehr als die ersten 500 im Bucket zu beschränken.
```
PS > $result = Get-S3Object -BucketName amzn-s3-demo-bucket1 -MaxKey 500 -NoAutoIteration
```
Um festzustellen, ob weitere Daten verfügbar, aber nicht zurückgegeben wurden, verwenden Sie den `-Select *` Parameter und das Argument und überprüfen Sie, ob die nächste Token-Eigenschaft einen Wert enthält.
Das folgende Beispiel gibt zurück`$true`, ob sich mehr als 500 Objekte im Bucket befinden, und `$false` andernfalls.
```
PS > $result = Get-S3Object -BucketName amzn-s3-demo-bucket1 -MaxKey 500 -NoAutoIteration -Select *
PS > $null -eq $result.NextMarker
```
**Anmerkung**
Die Namen der nächsten Token-Antworteigenschaft und des nächsten Cmdlet-Parameters variieren je nach Cmdlet. Einzelheiten finden Sie in der Hilfedokumentation zu den einzelnen Cmdlets.
### Manuelle Iteration
Im folgenden Beispiel werden alle S3-Objekte aus einem Bucket mithilfe einer [Do-Schleife](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_do) zurückgegeben, die die Bedingung nach jeder Iteration auswertet. Die `do` Schleife führt Iterationen durch, bis der Wert `$result.NextMarker` auf `Get-S3Object` 0 gesetzt ist`$null`, was bedeutet, dass keine ausgelagerten Daten mehr übrig sind. Die Ausgabe der Schleife wird der Variablen zugewiesen. `$s3Objects`
```
$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)
```
In diesem Beispiel wird PowerShell [Splatting](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_splatting) verwendet, um eine lange Codezeile zu vermeiden, die durch die Inline-Deklaration von Parametern und Argumenten verursacht würde.
# Zusätzliche Informationen über Benutzer und Rollen
Um Tools for PowerShell Commands ausführen zu können AWS, benötigen Sie eine Kombination aus Benutzern, Berechtigungssätzen und Servicerollen, die für Ihre Aufgaben geeignet ist.
Welche spezifischen Benutzer, Berechtigungssätze und Servicerollen Sie erstellen und wie Sie sie verwenden, hängt von Ihren Anforderungen ab. Im Folgenden finden Sie einige zusätzliche Informationen darüber, warum sie verwendet werden können und wie sie erstellt werden.
## Benutzer und Berechtigungssätze
Es ist zwar möglich, ein IAM-Benutzerkonto mit langfristigen Anmeldeinformationen für den Zugriff auf AWS -Services zu verwenden, dies ist jedoch keine bewährte Methode mehr und sollte vermieden werden. Selbst während der Entwicklung hat es sich bewährt, Benutzer und Berechtigungssätze in einer Identitätsquelle zu erstellen AWS IAM Identity Center und temporäre Anmeldeinformationen zu verwenden, die von einer Identitätsquelle bereitgestellt werden.
Für die Entwicklung können Sie den Benutzer verwenden, den Sie erstellt haben oder den Sie in [Authentifizierung mit AWS](creds-idc.md) erhalten haben. Wenn Sie über die entsprechenden AWS-Managementkonsole Berechtigungen verfügen, können Sie auch verschiedene Berechtigungssätze mit den geringsten Rechten für diesen Benutzer erstellen oder neue Benutzer speziell für Entwicklungsprojekte erstellen, indem Sie Berechtigungssätze mit den geringsten Rechten bereitstellen. Die Vorgehensweise, die Sie auswählen (sofern Sie dies tun), hängt von Ihren Umständen ab.
Weitere Informationen zu diesen Benutzern und Berechtigungssätzen sowie zu deren Erstellung finden Sie unter [Authentifizierung und Zugriff](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) im *AWS SDKs Referenzhandbuch zu Tools* und [Erste Schritte](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html) im *AWS IAM Identity Center Benutzerhandbuch*.
## Servicerollen
Sie können eine AWS Servicerolle einrichten, um im Namen von Benutzern auf AWS Dienste zuzugreifen. Diese Art des Zugriffs ist geeignet, wenn mehrere Personen Ihre Anwendung remote ausführen, z. B. auf einer EC2 Amazon-Instance, die Sie zu diesem Zweck erstellt haben.
Das Verfahren zur Erstellung einer Servicerolle ist je nach Situation unterschiedlich, sieht aber im Wesentlichen wie folgt aus.
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Wählen Sie **Roles (Rollen)** und anschließend **Create role (Rolle erstellen)**.
1. Wählen Sie **AWS Service**, suchen und wählen Sie **EC2**(zum Beispiel) und wählen Sie dann den **EC2**Anwendungsfall aus (zum Beispiel).
1. Wählen Sie **Weiter** und wählen Sie die [entsprechenden Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) für die AWS Dienste aus, die Ihre Anwendung verwenden soll.
**Warnung**
Wählen Sie ***NICHT*** die **AdministratorAccess**Richtlinie aus, da diese Richtlinie Lese- und Schreibberechtigungen für fast alles in Ihrem Konto ermöglicht.
1. Wählen Sie **Weiter** aus. Geben Sie einen **Rollennamen**, eine **Beschreibung** und alle gewünschten Tags ein.
Informationen zu Tags finden Sie unter [Steuern des Zugriffs mithilfe von AWS Ressourcen-Tags](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html) im [IAM-Benutzerhandbuch](https://docs.aws.amazon.com/IAM/latest/UserGuide/).
1. Wählen Sie **Rolle erstellen** aus.
Allgemeine Informationen zu IAM-Rollen finden Sie unter [IAM-Identitäten (Benutzer, Benutzergruppen und Rollen)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html#id_iam-roles) im [IAM-Benutzerhandbuch](https://docs.aws.amazon.com/IAM/latest/UserGuide/). Ausführliche Informationen zu Rollen finden Sie im Thema [IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).
# Verwenden von Legacy-Anmeldeinformationen
Die Themen in diesem Abschnitt enthalten Informationen zur Verwendung von lang- oder kurzfristigen Anmeldeinformationen ohne Verwendung von AWS IAM Identity Center.
**Warnung**
Um Sicherheitsrisiken zu vermeiden, sollten Sie IAM-Benutzer nicht zur Authentifizierung verwenden, wenn Sie speziell entwickelte Software entwickeln oder mit echten Daten arbeiten. Verwenden Sie stattdessen den Verbund mit einem Identitätsanbieter wie [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html).
**Anmerkung**
Die Informationen in diesen Themen beziehen sich auf Situationen, in denen Sie kurz- oder langfristige Anmeldeinformationen manuell abrufen und verwalten müssen. Weitere Informationen zu kurz- und langfristigen Anmeldeinformationen finden Sie unter [Andere Authentifizierungsmethoden im AWS SDKs Referenzhandbuch zu](https://docs.aws.amazon.com/sdkref/latest/guide/access-users.html) *Tools.*
Bewährte Sicherheitspraktiken finden Sie AWS IAM Identity Center wie unter beschrieben[Authentifizierung mit AWS](creds-idc.md).
## Wichtige Warnhinweise und Richtlinien für Anmeldeinformationen
**Warnhinweise für Anmeldeinformationen**
+ Verwenden ***Sie NICHT*** die Root-Anmeldeinformationen Ihres Kontos, um auf AWS Ressourcen zuzugreifen. Diese Anmeldeinformationen bieten uneingeschränkten Zugriff auf Konten und können nur schwer widerrufen werden.
+ Fügen Sie in Ihren Befehlen oder Skripten ***KEINE*** literalen Zugriffsschlüssel oder Anmeldeinformationen ein. Andernfalls besteht die Gefahr, dass Sie Ihre Anmeldeinformationen versehentlich preisgeben.
+ Beachten Sie, dass alle in der gemeinsam genutzten AWS `credentials` Datei gespeicherten Anmeldeinformationen im Klartext gespeichert werden.
**Zusätzliche Hinweise zur sicheren Verwaltung von Anmeldeinformationen**
Eine allgemeine Erläuterung der sicheren Verwaltung von AWS Anmeldeinformationen finden Sie unter [AWS Sicherheitsanmeldedaten](https://docs.aws.amazon.com/general/latest/gr/Welcome.html#aws-security-credentials) im [Allgemeine AWS-Referenz](https://docs.aws.amazon.com/general/latest/gr/)[IAM-Benutzerhandbuch](https://docs.aws.amazon.com/IAM/latest/UserGuide/) [und Bewährte Sicherheitsmethoden und Anwendungsfälle](https://docs.aws.amazon.com/IAM/latest/UserGuide/IAMBestPracticesAndUseCases.html). Berücksichtigen Sie zusätzlich zu diesen Informationen Folgendes:
+ Erstellen Sie zusätzliche Benutzer, z. B. Benutzer in IAM Identity Center, und verwenden Sie deren Anmeldeinformationen anstelle Ihrer AWS -Root-Benutzeranmeldeinformationen. Anmeldeinformationen für andere Benutzer können bei Bedarf widerrufen werden oder sind temporärer Natur. Darüber hinaus können Sie auf jeden Benutzer eine Richtlinie anwenden, die nur den Zugriff auf bestimmte Ressourcen und Aktionen vorsieht und so eine Einstellung der Rechte mit den geringsten Berechtigungen einräumt.
+ Verwenden Sie [IAM-Rollen für Aufgaben](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) in Verbindung mit Aufgaben von Amazon Elastic Container Service (Amazon ECS).
+ Verwenden Sie [IAM-Rollen](shared-credentials-in-aws-powershell.md#shared-credentials-assume-role) für Anwendungen, die auf Amazon-EC2-Instances ausgeführt werden.
**Topics**
+ [Wichtige Warnhinweise und Richtlinien](#pstools-creds-warnings-and-guidelines)
+ [AWS Erweitern Sie im angezeigten Detailbereich die Option](specifying-your-aws-credentials.md)
+ [Gemeinsame Anmeldeinformationen](shared-credentials-in-aws-powershell.md)
# AWS Anmeldeinformationen verwenden
Jeder AWS -Tools für PowerShell Befehl muss eine Reihe von AWS Anmeldeinformationen enthalten, mit denen die entsprechende Webdienstanforderung kryptografisch signiert wird. Sie können Anmeldeinformationen pro Befehl, pro Sitzung oder für alle Sitzungen angeben.
**Warnung**
Um Sicherheitsrisiken zu vermeiden, sollten Sie IAM-Benutzer nicht zur Authentifizierung verwenden, wenn Sie speziell entwickelte Software entwickeln oder mit echten Daten arbeiten. Verwenden Sie stattdessen den Verbund mit einem Identitätsanbieter wie [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html).
**Anmerkung**
Die Informationen in diesem Thema beziehen sich auf Situationen, in denen Sie kurz- oder langfristige Anmeldeinformationen manuell abrufen und verwalten müssen. Weitere Informationen zu kurz- und langfristigen Anmeldeinformationen finden Sie unter [Andere Authentifizierungsmethoden im Referenzhandbuch *AWS SDKs und im Tools-Referenzhandbuch*](https://docs.aws.amazon.com/sdkref/latest/guide/access-users.html).
Bewährte Sicherheitspraktiken finden Sie AWS IAM Identity Center wie unter beschrieben[Authentifizierung mit AWS](creds-idc.md).
Es ist ratsam, die Anmeldeinformationen nicht literal in einem Befehl anzugeben, um deren Offenlegung zu vermeiden. Erstellen Sie stattdessen ein Profil für jeden Satz von Anmeldeinformationen, den Sie verwenden möchten, und speichern Sie es an einem der beiden Speicherorte für Anmeldeinformationen. Geben Sie den Namen des betreffenden Profils im Befehl an, damit die AWS -Tools für PowerShell die zugehörigen Anmeldeinformationen abrufen. Eine allgemeine Erläuterung der sicheren Verwaltung von AWS Anmeldeinformationen finden Sie unter [Bewährte Methoden für die Verwaltung von AWS Zugriffsschlüsseln](https://docs.aws.amazon.com/general/latest/gr/aws-access-keys-best-practices.html) in der *Allgemeine Amazon Web Services-Referenz*.
**Anmerkung**
Sie benötigen ein AWS Konto, um Anmeldeinformationen zu erhalten und das zu verwenden AWS -Tools für PowerShell. Informationen zum Erstellen eines AWS Kontos finden Sie unter [Erste Schritte: Sind Sie ein AWS Erstbenutzer?](https://docs.aws.amazon.com/accounts/latest/reference/welcome-first-time-user.html) im *AWS -Kontenverwaltung Referenzhandbuch.*
**Topics**
+ [Speicherorte für Anmeldeinformationen](#specifying-your-aws-credentials-store)
+ [Verwalten von Profilen](#managing-profiles)
+ [Festlegen von Anmeldeinformationen](#specifying-your-aws-credentials-use)
+ [Suchreihenfolge für Anmeldeinformationen](#pstools-cred-provider-chain-legacy)
+ [Umgang mit Anmeldeinformationen in AWS Tools for PowerShell Core](#credential-handling-in-aws-tools-for-powershell-core)
## Speicherorte für Anmeldeinformationen
Sie AWS -Tools für PowerShell können einen von zwei Anmeldeinformationsspeichern verwenden:
+ Der AWS SDK-Speicher, der Ihre Anmeldeinformationen verschlüsselt und in Ihrem Home-Ordner speichert. In Windows befindet sich dieser Speicher unter: `C:\Users\username\AppData\Local\AWSToolkit\RegisteredAccounts.json`.
Der [AWS SDK für .NET](https://aws.amazon.com/sdk-for-net/) und [Toolkit for Visual Studio](https://aws.amazon.com/visualstudio/) auch den AWS SDK-Speicher.
+ Die Datei mit gemeinsamen Anmeldeinformationen, die sich ebenfalls im Basisordner befindet, in der die Daten allerdings als Klartext gespeichert werden.
Die Datei mit Anmeldeinformationen wird standardmäßig in folgendem Pfad gespeichert:
+ Bei Windows: `C:\Users\username\.aws\credentials`
+ Unter Mac/Linux: `~/.aws/credentials`
Der AWS SDKs und der AWS Command Line Interface kann auch die Anmeldeinformationsdatei verwenden. Wenn Sie ein Skript außerhalb Ihres AWS Benutzerkontextes ausführen, stellen Sie sicher, dass die Datei, die Ihre Anmeldeinformationen enthält, an einen Speicherort kopiert wird, an dem alle Benutzerkonten (lokales System und Benutzer) auf Ihre Anmeldeinformationen zugreifen können.
## Verwalten von Profilen
Mit Profilen können Sie auf verschiedene Gruppen von Anmeldeinformationen verweisen AWS -Tools für PowerShell. Sie können AWS -Tools für PowerShell Cmdlets verwenden, um Ihre Profile im AWS SDK-Speicher zu verwalten. Sie können Profile im AWS -SDK-Speicher auch mit dem [Toolkit for Visual Studio](https://docs.aws.amazon.com/AWSToolkitVS/latest/UserGuide/tkv_setup.html) oder programmgesteuert über das [AWS SDK für .NET](https://aws.amazon.com/sdk-for-net/) verwalten. Anweisungen zur Verwaltung von Profilen in der Anmeldeinformationsdatei finden Sie unter [Bewährte Methoden für die Verwaltung von AWS Zugriffsschlüsseln](https://docs.aws.amazon.com/general/latest/gr/aws-access-keys-best-practices.html).
### Hinzufügen eines neuen Profils
Führen Sie den Befehl aus, um dem AWS SDK-Speicher ein neues Profil hinzuzufügen`Set-AWSCredential`. Dieser speichert Ihren Zugriffsschlüssel und Ihren geheimen Schlüssel in der Standarddatei mit Anmeldeinformationen unter dem von Ihnen angegebenen Profilnamen.
```
PS > Set-AWSCredential `
-AccessKey AKIA0123456787EXAMPLE `
-SecretKey wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY `
-StoreAs MyNewProfile
```
+ `-AccessKey` – Die Zugriffsschlüssel-ID.
+ `-SecretKey`: Geheimer Schlüssel
+ `-StoreAs`: Profilname, der eindeutig sein muss Verwenden Sie den Namen `default`, um das Standardprofil anzugeben.
### Aktualisieren eines Profils
Der AWS SDK-Speicher muss manuell verwaltet werden. Wenn Sie später die Anmeldeinformationen für den Service ändern (z. B. über die [IAM-Konsole](https://console.aws.amazon.com/iam/home)), wird beim Ausführen eines Befehls mit den lokal gespeicherten Anmeldeinformationen die folgende Fehlermeldung angezeigt:
```
The Access Key Id you provided does not exist in our records.
```
Sie können ein Profil aktualisieren, indem Sie für dieses den Befehl `Set-AWSCredential` erneut eingeben und dabei den neuen Zugriffsschlüssel und den geheimen Schlüssel übergeben.
### Auflisten von Profilen
Sie können die aktuelle Namensliste mit dem folgenden Befehl überprüfen. In diesem Beispiel hat ein Benutzer namens Shirley Zugriff auf drei Profile, die alle in der Datei mit gemeinsamen Anmeldeinformationen (`~/.aws/credentials`) gespeichert sind.
```
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
```
### Entfernen eines Profils
Verwenden Sie den folgenden Befehl, um ein Profil zu entfernen, das Sie nicht mehr benötigen.
```
PS > Remove-AWSCredentialProfile -ProfileName an-old-profile-I-do-not-need
```
Der Parameter `-ProfileName` gibt das Profil an, das Sie löschen möchten.
Der veraltete Befehl [Clear- AWSCredential](https://docs.aws.amazon.com/powershell/v5/reference/items/Clear-AWSCredential.html) ist aus Gründen der Abwärtskompatibilität weiterhin verfügbar, wird aber `Remove-AWSCredentialProfile` bevorzugt.
## Festlegen von Anmeldeinformationen
Anmeldeinformationen können auf mehrere Arten festgelegt werden. Die bevorzugte Methode besteht darin, ein Profil zu identifizieren, anstatt wörtliche Anmeldeinformationen in Ihre Befehlszeile zu integrieren. AWS -Tools für PowerShell sucht das Profil anhand einer Suchreihenfolge, die unter Suchreihenfolge für [Anmeldeinformationen](#pstools-cred-provider-chain-legacy) beschrieben ist.
Unter Windows werden die im AWS SDK-Speicher gespeicherten AWS Anmeldeinformationen mit der angemeldeten Windows-Benutzeridentität verschlüsselt. Sie können nicht mit einem anderen Konto entschlüsselt oder auf einem Gerät verwendet werden, das sich von dem Gerät unterscheidet, auf dem sie ursprünglich erstellt wurden. Wenn Sie Aufgaben durchführen möchten, für die die Anmeldeinformationen eines anderen Benutzers erforderlich sind, z. B. ein Benutzerkonto, unter dem eine geplante Aufgabe ausgeführt wird, erstellen Sie wie im vorherigen Abschnitt beschrieben ein Anmeldeprofil, das Sie zum Anmelden als der entsprechende Benutzer auf dem Computer verwenden können. Melden Sie sich als Benutzer mit der Aufgabe an, um die Schritte zum Einrichten von Anmeldeinformationen abzuschließen, und erstellen Sie ein Profil, das für diesen Benutzer funktioniert. Melden Sie sich dann ab und mit Ihren eigenen Anmeldeinformationen erneut an, um die geplante Aufgabe einzurichten.
**Anmerkung**
Geben Sie das Profil mit dem Parameter `-ProfileName` an. Dieser Parameter entspricht dem `-StoredCredentials` Parameter in früheren Versionen. AWS -Tools für PowerShell Aus Gründen der Abwärtskompatibilität wird `-StoredCredentials` weiterhin unterstützt.
### Standardprofil (empfohlen)
Alle AWS SDKs und Verwaltungstools können Ihre Anmeldeinformationen automatisch auf Ihrem lokalen Computer finden, wenn die Anmeldeinformationen in einem Profil mit dem Namen gespeichert sind`default`. Wenn Sie beispielsweise über ein Profil mit dem Namen `default` auf dem lokalen Computer verfügen, müssen Sie weder das Cmdlet `Initialize-AWSDefaultConfiguration` noch das Cmdlet `Set-AWSCredential` ausführen. Die Tools verwenden automatisch die Zugriffs- und geheimen Schlüsseldaten, die in diesem Profil gespeichert sind. Um eine andere AWS -Region als Ihre Standardregion zu verwenden (die Ergebnisse von `Get-DefaultAWSRegion`), können Sie `Set-DefaultAWSRegion` ausführen und eine Region angeben.
Wenn Ihr Profil nicht `default` heißt, aber Sie es als Standardprofil für die aktuelle Sitzung verwenden möchten, führen Sie `Set-AWSCredential` aus, um es als Standardprofil festzulegen.
Beim Ausführen `Initialize-AWSDefaultConfiguration` können Sie zwar für jede PowerShell Sitzung ein Standardprofil angeben, das Cmdlet lädt jedoch Anmeldeinformationen aus Ihrem benutzerdefinierten Profil, überschreibt das Profil jedoch mit dem benannten `default` Profil.
Wir empfehlen, die Ausführung nur durchzuführen, `Initialize-AWSDefaultConfiguration` wenn Sie eine PowerShell Sitzung auf einer Amazon EC2 EC2-Instance ausführen, die nicht mit einem Instance-Profil gestartet wurde, und Sie möchten das Anmeldeinformationsprofil manuell einrichten. Beachten Sie, dass das Anmeldeinformationsprofil in diesem Szenario keine Anmeldeinformationen enthalten würde. Das Anmeldeinformationsprofil, das sich aus der Ausführung von `Initialize-AWSDefaultConfiguration` auf einer EC2-Instance ergibt, speichert Anmeldeinformationen nicht direkt. Stattdessen verweist es auf Instance-Metadaten (die temporäre Anmeldeinformationen bereitstellen, die automatisch rotiert werden). Es speichert jedoch die Region der Instance. Ein anderes Szenario, in dem es erforderlich sein könnte, `Initialize-AWSDefaultConfiguration` auszuführen, liegt vor, wenn Sie einen Aufruf für eine andere Region ausführen möchten, als für die Region, in der die Instance ausgeführt wird. Dieser Befehl überschreibt permanent die Region, die in den Instance-Metadaten gespeichert ist.
```
PS > Initialize-AWSDefaultConfiguration -ProfileName MyProfileName -Region us-west-2
```
**Anmerkung**
Die Standardanmeldedaten sind im AWS SDK-Speicher unter dem `default` Profilnamen enthalten. Der Befehl überschreibt ein evtl. vorhandenes Profil mit diesem Namen.
Wenn Ihre EC2-Instance mit einem Instance-Profil gestartet wurde, PowerShell werden die AWS Anmeldeinformationen und Regionsinformationen automatisch aus dem Instance-Profil abgerufen. Es ist nicht notwendig, `Initialize-AWSDefaultConfiguration` auszuführen. Das Ausführen des `Initialize-AWSDefaultConfiguration` Cmdlets auf einer EC2-Instance, die mit einem Instance-Profil gestartet wurde, ist nicht erforderlich, da es dieselben Instance-Profildaten verwendet, die PowerShell bereits standardmäßig verwendet werden.
### Sitzungsprofil
Mit dem Befehl `Set-AWSCredential` können Sie ein Standardprofil für eine bestimmte Sitzung festlegen. Dieses Profil setzt während der Sitzung jedes Standardprofil außer Kraft. Dies wird empfohlen, wenn Sie in Ihrer Sitzung anstelle des aktuellen `default`-Profils ein Profil mit benutzerdefiniertem Namen verwenden möchten.
```
PS > Set-AWSCredential -ProfileName MyProfileName
```
**Anmerkung**
In Versionen der Tools für Windows PowerShell , die älter als 1.1 sind, funktionierte das `Set-AWSCredential` Cmdlet nicht richtig und überschrieb das mit "" angegebene Profil. MyProfileName Es wird empfohlen, eine neuere Version der Tools für Windows zu verwenden. PowerShell
### Befehlsprofil
Bei einzelnen Befehlen können Sie den Parameter `-ProfileName` hinzufügen, um ein Profil anzugeben, das nur für diesen Befehl gilt. Dieses Profil überschreibt alle Standard- oder Sitzungsprofile, wie im folgenden Beispiel gezeigt.
```
PS > Get-EC2Instance -ProfileName MyProfileName
```
**Anmerkung**
Wenn Sie ein Standard- oder Sitzungsprofil festlegen, können Sie mit dem Parameter `-Region` eine Standard- oder Sitzungsregion überschreiben. Weitere Informationen finden Sie unter [Geben Sie die AWS Region für AWS -Tools für PowerShell](pstools-installing-specifying-region.md). Im folgenden Beispiel werden ein Standardprofil und eine Standardregion festgelegt.
```
PS > Initialize-AWSDefaultConfiguration -ProfileName MyProfileName -Region us-west-2
```
Standardmäßig wird davon ausgegangen, dass sich die Datei mit den AWS gemeinsamen Anmeldeinformationen im Home-Ordner des Benutzers befindet (`C:\Users\username\.aws`unter Windows oder `~/.aws` Linux). Um eine Datei mit Anmeldeinformationen an einem anderen Speicherort anzugeben, fügen Sie den Parameter `-ProfileLocation` ein und geben Sie den Pfad der Datei mit Anmeldeinformationen an. Im folgenden Beispiel wird eine andere als die Standard-Anmeldeinformationsdatei für einen bestimmten Befehl angegeben.
```
PS > Get-EC2Instance -ProfileName MyProfileName -ProfileLocation C:\aws_service_credentials\credentials
```
**Anmerkung**
Wenn Sie ein PowerShell Skript zu einem Zeitpunkt ausführen, AWS für den Sie normalerweise nicht angemeldet sind, z. B. wenn Sie ein PowerShell Skript als geplante Aufgabe außerhalb Ihrer normalen Arbeitszeiten ausführen, fügen Sie den `-ProfileLocation` Parameter hinzu, wenn Sie das Profil angeben, das Sie verwenden möchten, und legen Sie den Wert auf den Pfad der Datei fest, in der Ihre Anmeldeinformationen gespeichert sind. Um sicherzustellen, dass Ihr AWS -Tools für PowerShell Skript mit den richtigen Kontoanmeldeinformationen ausgeführt wird, sollten Sie den `-ProfileLocation` Parameter immer dann hinzufügen, wenn Ihr Skript in einem Kontext oder Prozess ausgeführt wird, der kein AWS Konto verwendet. Sie können die Anmeldeinformationsdatei auch an einen Speicherort kopieren, der für das lokale System oder das andere Konto zugänglich ist, das von den Skripts zum Ausführen von Aufgaben verwendet wird.
## Suchreihenfolge für Anmeldeinformationen
Wenn Sie einen Befehl ausführen, wird in der folgenden Reihenfolge nach Anmeldeinformationen AWS -Tools für PowerShell gesucht. Dieser Vorgang wird beendet, wenn verwendbare Anmeldeinformationen gefunden wurden.
1. Literale Anmeldeinformationen, die als Parameter in der Befehlszeile eingebettet sind.
Wir empfehlen dringend, Profile zu verwenden, anstatt literale Anmeldeinformationen in die Befehlszeile einzugeben.
1. Mit dem Parameter `-Credential` angegebene Anmeldeinformationen.
1. Ein Profilname oder ein Profilspeicherort, der mit dem AWSCredential Cmdlet [Set-](https://docs.aws.amazon.com/powershell/v5/reference/items/Set-AWSCredential.html) angegeben wurde.
+ Wenn Sie nur einen Profilnamen angeben, sucht der Befehl im AWS SDK-Speicher nach dem angegebenen Profil und, falls dieses nicht vorhanden ist, nach dem angegebenen Profil aus der Datei mit den AWS gemeinsamen Anmeldeinformationen am Standardspeicherort.
+ Wenn Sie nur einen Profilspeicherort angeben, wird bei Ausführung des Befehls das `default`-Profil in dieser Datei mit Anmeldeinformationen gesucht.
+ Wenn Sie sowohl einen Namen als auch einen Speicherort angeben, wird bei Ausführung des Befehls nach dem angegebenen Profil in dieser Datei mit Anmeldeinformationen gesucht.
Wenn der angegebene Profilname oder Speicherort nicht gefunden wird, löst der Befehl eine Ausnahme aus. Die folgenden Suchschritte werden nur durchgeführt, wenn Sie kein Profil und keinen Speicherort angegeben haben.
1. Anmeldeinformationen, die aus den `AWS_SESSION_TOKEN` Umgebungsvariablen `AWS_ACCESS_KEY_ID``AWS_SECRET_ACCESS_KEY`, und erstellt werden, wenn alle drei Variablen einen Wert haben.
1. Das Anmeldeinformationsprofil mit dem in der `AWS_PROFILE` Umgebungsvariablen angegebenen Namen.
1. Das Standardprofil in der folgenden Reihenfolge:
1. Das `default` Profil im AWS SDK-Speicher.
1. Das `default` Profil in der gemeinsam genutzten AWS `credentials` Datei.
1. Das `AWS PS Default` Profil im AWS SDK-Speicher.
1. Wenn der Befehl auf einer Amazon-EC2-Instance ausgeführt wird, die für die Verwendung einer IAM-Rolle konfiguriert ist, werden die temporären Anmeldeinformationen der EC2-Instance über das Instance-Profil aufgerufen.
Weitere Informationen zur Verwendung von IAM-Rollen für Amazon EC2 EC2-Instances finden Sie unter [Granting access with a role](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-hosm.html) im [AWS SDK für .NET Developer](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/) Guide.
Wenn die angegebenen Anmeldeinformationen im Rahmen dieser Suche nicht gefunden werden, löst der Befehl eine Ausnahme aus.
Weitere Informationen zu Umgebungsvariablen und Profilen mit Anmeldeinformationen finden Sie in den folgenden Themen im [Referenzhandbuch zu Tools: [Umgebungsvariablen](https://docs.aws.amazon.com/sdkref/latest/guide/environment-variables.html), [Liste der Umgebungsvariablen AWS SDKs ](https://docs.aws.amazon.com/sdkref/latest/guide/settings-reference.html#EVarSettings) und](https://docs.aws.amazon.com/sdkref/latest/guide/) Dateien mit [gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html).
## Umgang mit Anmeldeinformationen in AWS Tools for PowerShell Core
Cmdlets in AWS Tools for PowerShell Core akzeptieren AWS Zugriffs- und geheime Schlüssel oder die Namen von Anmeldeinformationsprofilen, wenn sie ausgeführt werden, ähnlich wie die. AWS Tools for Windows PowerShell Bei Ausführung unter Windows haben beide Module Zugriff auf die Datei mit AWS SDK für .NET -Anmeldeinformationen (gespeichert in der benutzerspezifischen Datei `AppData\Local\AWSToolkit\RegisteredAccounts.json`).
Diese Datei speichert die Schlüssel verschlüsselt und kann nicht auf einem anderen Computer verwendet werden. Es ist die erste Datei, die AWS -Tools für PowerShell nach einem Anmeldeinformationsprofil sucht, und sie ist auch die Datei, in der die Anmeldeinformationsprofile gespeichert werden. AWS -Tools für PowerShell [Weitere Informationen zur Datei mit dem AWS SDK für .NET Anmeldeinformationsspeicher finden Sie unter Anmeldeinformationen konfigurieren. AWS](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-config-creds.html) Das PowerShell Modul Tools für Windows unterstützt derzeit nicht das Schreiben von Anmeldeinformationen in andere Dateien oder Speicherorte.
Beide Module können Profile aus der Datei mit AWS gemeinsamen Anmeldeinformationen lesen, die von anderen verwendet wird, AWS SDKs und von AWS CLI. Unter Windows heißt das Standardverzeichnis für diese Datei `C:\Users\\.aws\credentials`. Unter anderen Betriebssystem wird die Datei im Verzeichnis `~/.aws/credentials` gespeichert. Wenn nicht der Standarddateiname oder -speicherort verwendet wird, kann der betreffende Pfad mit dem Parameter `-ProfileLocation` angegeben werden.
Der SDK-Anmeldeinformationsspeicher speichert Ihre Anmeldeinformationen in verschlüsselter Form mithilfe von Windows-Kryptografie. APIs Diese APIs sind auf anderen Plattformen nicht verfügbar, daher verwendet das AWS Tools for PowerShell Core Modul ausschließlich die Datei mit AWS gemeinsam genutzten Anmeldeinformationen und unterstützt das Schreiben neuer Anmeldeinformationsprofile in die gemeinsam genutzte Anmeldeinformationsdatei.
**Die folgenden Beispielskripts, die das `Set-AWSCredential` Cmdlet verwenden, zeigen die Optionen für die Verarbeitung von Anmeldeinformationsprofilen unter Windows entweder mit der Shell oder der Shell. AWSPower AWSPower** ** NetCore**Module.
```
# 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
```
Die folgenden Beispiele zeigen das Verhalten der **AWSPowerShell. NetCore**Modul auf den Betriebssystemen Linux oder 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
```
# Geteilte Anmeldeinformationen in AWS -Tools für PowerShell
Die Tools für Windows PowerShell unterstützen die Verwendung der Datei AWS mit gemeinsamen Anmeldeinformationen, ähnlich wie die AWS CLI und andere AWS SDKs. Die Tools für Windows unterstützen PowerShell jetzt das Lesen und Schreiben von `basic``session`, und `assume role` Anmeldeinformationsprofilen sowohl in die .NET-Anmeldeinformationsdatei als auch in die AWS gemeinsam genutzte Anmeldeinformationsdatei. Diese Funktionalität wird durch einen neuen `Amazon.Runtime.CredentialManagement`-Namespace ermöglicht.
**Warnung**
Um Sicherheitsrisiken zu vermeiden, sollten Sie IAM-Benutzer nicht zur Authentifizierung verwenden, wenn Sie speziell entwickelte Software entwickeln oder mit echten Daten arbeiten. Verwenden Sie stattdessen den Verbund mit einem Identitätsanbieter wie [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html).
**Anmerkung**
Die Informationen in diesem Thema beziehen sich auf Situationen, in denen Sie kurz- oder langfristige Anmeldeinformationen manuell abrufen und verwalten müssen. Weitere Informationen zu kurz- und langfristigen Anmeldeinformationen finden Sie unter [Andere Authentifizierungsmethoden im Referenzhandbuch *AWS SDKs und im Tools-Referenzhandbuch*](https://docs.aws.amazon.com/sdkref/latest/guide/access-users.html).
Bewährte Sicherheitspraktiken finden Sie AWS IAM Identity Center wie unter beschrieben[Authentifizierung mit 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) In Service-Cmdlets können Sie auf Ihre Profile verweisen, indem Sie den allgemeinen Parameter `-ProfileName` hinzufügen.
## Verwenden einer IAM-Rolle mit AWS -Tools für PowerShell
Die AWS gemeinsam genutzte Anmeldeinformationsdatei ermöglicht zusätzliche Zugriffsarten. Sie können beispielsweise auf Ihre AWS Ressourcen zugreifen, indem Sie eine IAM-Rolle anstelle der langfristigen Anmeldeinformationen eines IAM-Benutzers verwenden. Dazu müssen Sie über ein Standardprofil verfügen, das über die erforderlichen Berechtigungen verfügt, um die Rolle zu übernehmen. Wenn Sie dem mitteilen, dass er ein Profil verwenden AWS -Tools für PowerShell soll, das eine Rolle angegeben hat, AWS -Tools für PowerShell sucht er nach dem durch den `SourceProfile` Parameter identifizierten Profil. Diese Anmeldeinformationen werden verwendet, um temporäre Anmeldeinformationen für die durch den Parameter `RoleArn` angegebene Rolle anzufordern. Sie können optional die Verwendung eines Multi-Factor Authentication(MFA)-Geräts oder eines `ExternalId`-Codes verlangen, wenn die Rolle von einem Dritten übernommen wird.
****
| Name des Parameters | Description |
| --- | --- |
| ExternalId | Die benutzerdefinierte externe ID, die zu verwenden ist, wenn eine Rolle übernommen wird, für die dies erforderlich ist. Dies ist in der Regel nur erforderlich, wenn Sie den Zugriff auf Ihr Konto an Dritte delegieren. Der Drittanbieter muss den ExternalId als Parameter angeben, wenn er die zugewiesene Rolle übernimmt. Weitere Informationen finden Sie im *IAM-Benutzerhandbuch* unter [So verwenden Sie eine externe ID, wenn Sie einem Dritten Zugriff auf Ihre AWS Ressourcen gewähren](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html). |
| MfaSerial | Die MFA-Seriennummer, die zu verwenden ist, wenn eine Rolle übernommen wird, für die dies erforderlich ist. Weitere Informationen finden Sie unter [Verwenden der Multi-Faktor-Authentifizierung (MFA) in AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa.html) im *IAM-Benutzerhandbuch*. |
| RoleArn | Der ARN der übernommenen Rolle für übernommene Rollenanmeldeinformationen. Weitere Informationen zum Erstellen und Verwenden von Rollen finden Sie unter [IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) im *IAM-Benutzerhandbuch*. |
| SourceProfile | Der Name des Quellprofils, der von den übernommenen Rollenanmeldeinformationen zu verwenden ist. Die in diesem Profil gefundenen Anmeldeinformationen werden verwendet, um die durch den Parameter `RoleArn` angegebene Rolle zu übernehmen. |
### Einrichten von Profilen zur Übernahme einer Rolle
Im folgenden Beispiel wird gezeigt, wie ein Quellprofil eingerichtet wird, das die direkte Übernahme einer IAM-Rolle ermöglicht.
Mit dem ersten Befehl wird ein Quellprofil erstellt, auf das mit dem Rollenprofil verwiesen wird. Mit dem zweiten Befehl wird das Rollenprofil erstellt, das die Rolle übernehmen soll. Mit dem dritten Befehl werden die Anmeldeinformationen für das Rollenprofil angezeigt.
```
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
```
Um dieses Rollenprofil mit den PowerShell Dienst-Cmdlets Tools for Windows zu verwenden, fügen Sie dem Befehl den `-ProfileName` gemeinsamen Parameter hinzu, um auf das Rollenprofil zu verweisen. Im folgenden Beispiel wird das im vorherigen Beispiel definierte Rollenprofil für den Zugriff auf das [Get-S3Bucket](https://docs.aws.amazon.com/powershell/v5/reference/items/Get-S3Bucket.html)Cmdlet verwendet. AWS -Tools für PowerShell sucht nach den Anmeldeinformationen in`my_source_profile`, verwendet diese Anmeldeinformationen, um im Namen des Benutzers `AssumeRole` aufzurufen, und verwendet dann diese temporären Rollenanmeldeinformationen, um aufzurufen. `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
```
## Verwenden der Anmeldeinformationsprofil-Typen
Um einen Anmeldeinformationsprofil-Typ festlegen zu können, müssen Sie wissen, welche Parameter die für den Profiltyp erforderlichen Daten bereitstellen.
****
| Anmeldeinformationstyp | Parameter, die Sie verwenden müssen |
| --- | --- |
| **Basic** Dies sind die langfristigen Anmeldeinformationen für einen IAM-Benutzer | `-AccessKey` `-SecretKey` |
| **Sitzung** Dies sind die kurzfristigen Anmeldeinformationen für eine IAM-Rolle, die Sie manuell abrufen, z. B. indem Sie das STSRole Cmdlet [Use-](https://docs.aws.amazon.com/powershell/v5/reference/items/Use-STSRole.html) direkt aufrufen. | `-AccessKey` `-SecretKey` `-SessionToken` |
| **Rolle**: Dies sind kurzfristige Anmeldeinformationen für eine IAM-Rolle, die die AWS -Tools für PowerShell für Sie abrufen. | `-SourceProfile` `-RoleArn` Optional: `-ExternalId` Optional: `-MfaSerial` |
## Der allgemeine Parameter `ProfileLocation`
Sie können `-ProfileLocation` verwenden, um die gemeinsame Anmeldeinformationsdatei zu schreiben sowie ein Cmdlet anzuweisen, Daten in der Anmeldeinformationsdatei zu lesen. Durch das Hinzufügen des `-ProfileLocation` Parameters wird gesteuert, ob Tools für Windows die gemeinsam genutzte Anmeldeinformationsdatei oder die .NET-Anmeldeinformationsdatei PowerShell verwendet. In der folgenden Tabelle wird beschrieben, wie der Parameter in Tools für Windows funktioniert. PowerShell
****
| Profilpositionswert | Profilauflösungsverhalten |
| --- | --- |
| Null (nicht festgelegt) oder leer | Durchsuchen Sie zunächst die .NET-Anmeldeinformationsdatei für ein Profil mit dem angegebenen Namen. Wenn das Profil nicht gefunden wird, suchen Sie in der Datei AWS mit den gemeinsamen Anmeldeinformationen unter`(user's home directory)\.aws\credentials`. |
| Der Pfad zu einer Datei im Dateiformat AWS mit gemeinsam genutzten Anmeldeinformationen | Suchen Sie zunächst nur die angegebene Datei für ein Profil mit dem gegebenen Namen. |
### Speichern der Anmeldeinformationen in einer Anmeldeinformationsdatei
Führen Sie das Cmdlet `Set-AWSCredential` aus, um die Anmeldeinformationen in eine der beiden Anmeldeinformationsdateien zu schreiben und die Datei zu speichern. Das Verfahren wird im folgenden Beispiel gezeigt. Der erste Befehl verwendet `Set-AWSCredential` mit `-ProfileLocation`, um Zugriffs- und geheime Schlüssel zu einem durch den Parameter `-ProfileName` angegebenen Profil hinzuzufügen. Führen Sie in der zweiten Zeile das Cmdlet [Get-Content](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.management/get-content) aus, um den Inhalt der Anmeldeinformationsdatei anzuzeigen.
```
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
```
## Anzeigen von Anmeldeinformationsprofilen
Führen [Sie das AWSCredential Cmdlet Get-](https://docs.aws.amazon.com/powershell/v5/reference/items/Get-AWSCredential.html) aus und fügen Sie den `-ListProfileDetail` Parameter für die Rückgabe von Dateitypen und Speicherorten für Anmeldeinformationen sowie eine Liste mit Profilnamen hinzu.
```
PS > Get-AWSCredential -ListProfileDetail
ProfileName StoreTypeName ProfileLocation
----------- ------------- ---------------
source_profile NetSDKCredentialsFile
assume_role_profile NetSDKCredentialsFile
basic_profile SharedCredentialsFile C:\Users\auser\.aws\credentials
```
## Entfernen von Anmeldeinformationsprofilen
Um Anmeldeinformationsprofile zu entfernen, führen Sie das neue Cmdlet [Remove-Profile](https://docs.aws.amazon.com/powershell/v5/reference/items/Remove-AWSCredentialProfile.html) aus. AWSCredential [Clear- AWSCredential](https://docs.aws.amazon.com/powershell/v5/reference/items/Clear-AWSCredential.html) ist veraltet, aber aus Gründen der Abwärtskompatibilität weiterhin verfügbar.
## Wichtige Hinweise
Nur [Initialize- AWSDefault Configuration](https://docs.aws.amazon.com/powershell/v5/reference/items/Initialize-AWSDefaultConfiguration.html), [New- AWSCredential](https://docs.aws.amazon.com/powershell/v5/reference/items/New-AWSCredential.html) und [Set- AWSCredential](https://docs.aws.amazon.com/powershell/v5/reference/items/Set-AWSCredential.html) unterstützen die Parameter für Rollenprofile. Sie können die Rollenparameter nicht direkt in einem Befehl wie beispielsweise `Get-S3Bucket -SourceProfile source_profile_name -RoleArn arn:aws:iam::999999999999:role/role_name` angeben. Dies ist nicht möglich, da Dienst-Cmdlets die Parameter `RoleArn` oder `SourceProfile` nicht direkt unterstützen. Stattdessen müssen Sie diese Parameter in einem Profil speichern und dann den Befehl mit dem Parameter `-ProfileName` aufrufen.