Der AWS SDK für .NET V3 ist in den Wartungsmodus übergegangen.
Wir empfehlen Ihnen, auf [AWS SDK für .NET V4](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/welcome.html) zu migrieren. Weitere Einzelheiten und Informationen zur Migration finden Sie in unserer [Ankündigung zum Wartungsmodus](https://aws.amazon.com/blogs/developer/aws-sdk-for-net-v3-maintenance-mode-announcement/).
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.
# Codebeispiele mit Anleitungen für AWS SDK für .NET
Die folgenden Abschnitte enthalten Codebeispiele und Anleitungen zu den Beispielen. Sie können Ihnen helfen, zu lernen, wie Sie die verwenden AWS SDK für .NET , um mit AWS Diensten zu arbeiten.
Wenn Sie mit dem noch nicht vertraut sind AWS SDK für .NET, sollten Sie sich zuerst mit dem [Machen Sie einen kurzen Rundgang](quick-start.md) Thema befassen. Es gibt Ihnen eine Einführung in das SDK.
Bevor Sie beginnen, stellen Sie sicher, dass Sie [Ihre Umgebung und Ihr Projekt eingerichtet](net-dg-config.md) haben. Lesen Sie auch die Informationen unter[SDK-Funktionen](net-dg-sdk-features.md).
**Topics**
+ [CloudFormation](cloudformation-apis-intro.md)
+ [Amazon Cognito](cognito-apis-intro.md)
+ [DynamoDB](dynamodb-intro.md)
+ [Amazon EC2](ec2-apis-intro.md)
+ [IAM](iam-apis-intro.md)
+ [Amazon S3](s3-apis-intro.md)
+ [Amazon SNS](sns-apis-intro.md)
+ [Amazon SQS](sqs-apis-intro.md)
# Zugriff CloudFormation mit dem AWS SDK für .NET
Der AWS SDK für .NET Support [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/), der vorhersehbar und wiederholt AWS Infrastrukturbereitstellungen erstellt und bereitstellt.
## APIs
Das AWS SDK für .NET sorgt für Kunden APIs . CloudFormation Sie APIs ermöglichen es Ihnen, mit CloudFormation Funktionen wie Vorlagen und Stacks zu arbeiten. Dieser Abschnitt enthält eine kleine Anzahl von Beispielen, die Ihnen zeigen, welchen Mustern Sie bei der Arbeit mit diesen APIs Modellen folgen können. Den vollständigen Satz von APIs finden Sie in der [AWS SDK für .NET API-Referenz](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/) (und scrollen Sie zu „Amazon. CloudFormation„).
Die AWS CloudFormation APIs werden von der zur Verfügung gestellt [AWSSDK. CloudFormation](https://www.nuget.org/packages/AWSSDK.CloudFormation/)Paket.
## Voraussetzungen
Bevor Sie beginnen, stellen Sie sicher, dass Sie [Ihre Umgebung und Ihr Projekt eingerichtet](net-dg-config.md) haben. Lesen Sie auch die Informationen unter[SDK-Funktionen](net-dg-sdk-features.md).
## Topics
**Topics**
+ [APIs](#w2aac19c15c11b5)
+ [Voraussetzungen](#w2aac19c15c11b7)
+ [Topics](#w2aac19c15c11b9)
+ [AWS Ressourcen auflisten](cfn-list-resources.md)
# AWS Ressourcen auflisten mit AWS CloudFormation
Dieses Beispiel zeigt Ihnen, wie Sie AWS SDK für .NET die Ressourcen CloudFormation stapelweise auflisten können. Das Beispiel verwendet die Low-Level-API. Die Anwendung akzeptiert keine Argumente, sondern sammelt lediglich Informationen für alle Stacks, auf die die Anmeldeinformationen des Benutzers zugreifen können, und zeigt dann Informationen zu diesen Stacks an.
## SDK-Referenzen
NuGet Pakete:
+ [AWSSDK.CloudFormation](https://www.nuget.org/packages/AWSSDK.CloudFormation/)
Elemente der Programmierung:
+ Namespace [Amazon. CloudFormation](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudFormation/NCloudFormation.html)
Klasse [AmazonCloudFormationClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudFormation/TCloudFormationClient.html)
+ Namespace [Amazon. CloudFormation.Modell](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudFormation/NCloudFormationModel.html)
[Klasse ICloudFormationPaginatorFactory. DescribeStacks](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudFormation/MICloudFormationPaginatorFactoryDescribeStacksDescribeStacksRequest.html)
Klasse [DescribeStackResourcesRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudFormation/TDescribeStackResourcesRequest.html)
Klasse [DescribeStackResourcesResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudFormation/TDescribeStackResourcesResponse.html)
[Klassen-Stack](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudFormation/TStack.html)
Klasse [StackResource](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudFormation/TStackResource.html)
[Klassen-Tag](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudFormation/TTag.html)
```
using Amazon.CloudFormation;
using Amazon.CloudFormation.Model;
using Amazon.Runtime;
namespace CloudFormationActions;
public static class HelloCloudFormation
{
public static IAmazonCloudFormation _amazonCloudFormation;
static async Task Main(string[] args)
{
// Create the CloudFormation client
_amazonCloudFormation = new AmazonCloudFormationClient();
Console.WriteLine($"\nIn Region: {_amazonCloudFormation.Config.RegionEndpoint}");
// List the resources for each stack
await ListResources();
}
///
/// Method to list stack resources and other information.
///
/// True if successful.
public static async Task ListResources()
{
try
{
Console.WriteLine("Getting CloudFormation stack information...");
// Get all stacks using the stack paginator.
var paginatorForDescribeStacks =
_amazonCloudFormation.Paginators.DescribeStacks(
new DescribeStacksRequest());
await foreach (Stack stack in paginatorForDescribeStacks.Stacks)
{
// Basic information for each stack
Console.WriteLine("\n------------------------------------------------");
Console.WriteLine($"\nStack: {stack.StackName}");
Console.WriteLine($" Status: {stack.StackStatus.Value}");
Console.WriteLine($" Created: {stack.CreationTime}");
// The tags of each stack (etc.)
if (stack.Tags.Count > 0)
{
Console.WriteLine(" Tags:");
foreach (Tag tag in stack.Tags)
Console.WriteLine($" {tag.Key}, {tag.Value}");
}
// The resources of each stack
DescribeStackResourcesResponse responseDescribeResources =
await _amazonCloudFormation.DescribeStackResourcesAsync(
new DescribeStackResourcesRequest
{
StackName = stack.StackName
});
if (responseDescribeResources.StackResources.Count > 0)
{
Console.WriteLine(" Resources:");
foreach (StackResource resource in responseDescribeResources
.StackResources)
Console.WriteLine(
$" {resource.LogicalResourceId}: {resource.ResourceStatus}");
}
}
Console.WriteLine("\n------------------------------------------------");
return true;
}
catch (AmazonCloudFormationException ex)
{
Console.WriteLine("Unable to get stack information:\n" + ex.Message);
return false;
}
catch (AmazonServiceException ex)
{
if (ex.Message.Contains("Unable to get IAM security credentials"))
{
Console.WriteLine(ex.Message);
Console.WriteLine("If you are usnig SSO, be sure to install" +
" the AWSSDK.SSO and AWSSDK.SSOOIDC packages.");
}
else
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
return false;
}
catch (ArgumentNullException ex)
{
if (ex.Message.Contains("Options property cannot be empty: ClientName"))
{
Console.WriteLine(ex.Message);
Console.WriteLine("If you are using SSO, have you logged in?");
}
else
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
return false;
}
}
```
# Benutzer mit Amazon Cognito authentifizieren
**Anmerkung**
Die Informationen in diesem Thema beziehen sich speziell auf Projekte, die auf .NET Framework und AWS SDK für .NET Version 3.3 und früher basieren.
Mit Amazon Cognito Identity können Sie eindeutige Identitäten für Ihre Benutzer erstellen und sie für den sicheren Zugriff auf Ihre AWS Ressourcen wie Amazon S3 oder Amazon DynamoDB authentifizieren. Amazon Cognito Identity unterstützt öffentliche Identitätsanbieter wie Amazon, Facebook, Twitter/Digits, Google oder andere OpenID Connect-kompatible Anbieter sowie nicht authentifizierte Identitäten. Amazon Cognito unterstützt auch [entwicklerauthentifizierte Identitäten](https://aws.amazon.com/blogs/mobile/amazon-cognito-announcing-developer-authenticated-identities/), mit denen Sie Benutzer mithilfe Ihres eigenen Backend-Authentifizierungsprozesses registrieren und authentifizieren können, während Sie weiterhin Amazon Cognito Sync verwenden, um Benutzerdaten zu synchronisieren und auf Ressourcen zuzugreifen. AWS
Weitere Informationen zu [Amazon Cognito](https://aws.amazon.com/cognito/) finden Sie im [Amazon Cognito Developer Guide](https://docs.aws.amazon.com/cognito/latest/developerguide/).
Die folgenden Codebeispiele zeigen, wie Sie Amazon Cognito Identity einfach verwenden können. Das [Anmeldeinformationsanbieter](cognito-creds-provider.md) Beispiel zeigt, wie Benutzeridentitäten erstellt und authentifiziert werden. Das [CognitoAuthentication Erweiterungsbibliothek](cognito-authentication-extension.md) Beispiel zeigt, wie die CognitoAuthentication Erweiterungsbibliothek zur Authentifizierung von Amazon Cognito Cognito-Benutzerpools verwendet wird.
**Topics**
+ [Anmeldeinformationsanbieter](cognito-creds-provider.md)
+ [CognitoAuthentication Erweiterungsbibliothek](cognito-authentication-extension.md)
# Anbieter Amazon Cognito Cognito-Anmeldeinformationen
**Anmerkung**
Die Informationen in diesem Thema beziehen sich speziell auf Projekte, die auf .NET Framework und AWS SDK für .NET Version 3.3 und früher basieren.
`Amazon.CognitoIdentity.CognitoAWSCredentials`, gefunden in der [AWSSDK. CognitoIdentity](https://www.nuget.org/packages/AWSSDK.CognitoIdentity/) NuGetpackage, ist ein Anmeldeinformationsobjekt, das Amazon Cognito und the AWS -Security-Token-Service (AWS STS) verwendet, um Anmeldeinformationen für AWS Anrufe abzurufen.
Der erste Schritt beim Einrichten von `CognitoAWSCredentials` besteht darin, einen „Identitätspool“ zu erstellen. (In einem Identitätspool werden Benutzeridentitätsinformationen gespeichert, die speziell für Ihr Konto gelten.) Die Daten können über Client-Plattformen, Geräte und Betriebssysteme hinweg abgerufen werden, sodass die persistenten App-Informationen für einen Benutzer, der Ihre App zunächst auf einem Smartphone und später auf einem Tablet verwendet, noch verfügbar sind. Sie können über die Amazon Cognito Cognito-Konsole einen neuen Identitätspool erstellen. Wenn Sie die Konsole verwenden, erhalten Sie so auch andere Informationen, die Sie benötigen:
+ Ihre Kontonummer – Eine 12-stellige Zahl, z. B. 123456789012, die speziell für Ihr Konto gilt.
+ ARN der nicht authentifizierten Rolle – Eine Rolle, die von nicht authentifizierten Benutzern übernommen wird. Beispiel: Diese Rolle bietet schreibgeschützten Zugriff auf Ihre Daten.
+ ARN der authentifizierten Rolle – Eine Rolle, die von authentifizierten Benutzern übernommen wird. Diese Rolle kann einen umfassenderen Zugriff auf Ihre Daten gewähren.
## Cognito einrichten AWSCredentials
Das folgende Codebeispiel zeigt die Einrichtung`CognitoAWSCredentials`, die Sie dann verwenden können, um Amazon S3 als nicht authentifizierter Benutzer aufzurufen. Auf diese Weise können Sie Aufrufe mit nur einer minimale Menge an Daten machen, die für die Authentifizierung des Benutzers erforderlich ist. Da die Benutzerberechtigungen über die Rolle gesteuert werden, können Sie den Zugriff ganz nach Bedarf konfigurieren.
```
CognitoAWSCredentials credentials = new CognitoAWSCredentials(
accountId, // Account number
identityPoolId, // Identity pool ID
unAuthRoleArn, // Role for unauthenticated users
null, // Role for authenticated users, not set
region);
using (var s3Client = new AmazonS3Client(credentials))
{
s3Client.ListBuckets();
}
```
## AWS Als nicht authentifizierter Benutzer verwenden
Das folgende Codebeispiel zeigt, wie Sie mit der Verwendung AWS als nicht authentifizierter Benutzer beginnen, sich dann über Facebook authentifizieren und die Anmeldeinformationen aktualisieren können, um Facebook-Anmeldeinformationen zu verwenden. Mit diesem Ansatz können Sie authentifizierten Benutzern über die authentifizierte Rolle unterschiedliche Fähigkeiten erteilen. So ist beispielsweise eine Telefonanwendung möglich, die Benutzern die anonyme Ansicht von Inhalten gewährt, ihnen das Posten von Inhalten aber nur gestattet, wenn sie sich mit einem oder mehreren der konfigurierten Anbieter anmelden.
```
CognitoAWSCredentials credentials = new CognitoAWSCredentials(
accountId, identityPoolId,
unAuthRoleArn, // Role for unauthenticated users
authRoleArn, // Role for authenticated users
region);
using (var s3Client = new AmazonS3Client(credentials))
{
// Initial use will be unauthenticated
s3Client.ListBuckets();
// Authenticate user through Facebook
string facebookToken = GetFacebookAuthToken();
// Add Facebook login to credentials. This clears the current AWS credentials
// and retrieves new AWS credentials using the authenticated role.
credentials.AddLogin("graph.facebook.com", facebookAccessToken);
// This call is performed with the authenticated role and credentials
s3Client.ListBuckets();
}
```
Das `CognitoAWSCredentials`-Objekt bietet sogar noch mehr Funktionalität, wenn Sie es zusammen mit dem `AmazonCognitoSyncClient` verwenden, der Teil des AWS SDK für .NET ist. Wenn Sie sowohl als auch `AmazonCognitoSyncClient` verwenden`CognitoAWSCredentials`, müssen Sie die `IdentityId` Eigenschaften `IdentityPoolId` und nicht angeben, wenn Sie mit dem aufrufen. `AmazonCognitoSyncClient` Diese Eigenschaften werden automatisch aus `CognitoAWSCredentials` ausgefüllt. Dies wird im nächsten Codebeispiel zusammen mit einem Ereignis veranschaulicht, das Sie immer dann benachrichtigt, wenn sich die `IdentityId` für `CognitoAWSCredentials` ändert. In einigen Fällen kann sich die `IdentityId` ändern. So z. B. auch beim Wechsel von einem nicht authentifizierten zu einem authentifizierten Benutzer.
```
CognitoAWSCredentials credentials = GetCognitoAWSCredentials();
// Log identity changes
credentials.IdentityChangedEvent += (sender, args) =>
{
Console.WriteLine("Identity changed: [{0}] => [{1}]", args.OldIdentityId, args.NewIdentityId);
};
using (var syncClient = new AmazonCognitoSyncClient(credentials))
{
var result = syncClient.ListRecords(new ListRecordsRequest
{
DatasetName = datasetName
// No need to specify these properties
//IdentityId = "...",
//IdentityPoolId = "..."
});
}
```
# Beispiele Amazon CognitoAuthentication Amazon-Erweiterungsbibliotheken
**Anmerkung**
Die Informationen in diesem Thema beziehen sich speziell auf Projekte, die auf .NET Framework und AWS SDK für .NET Version 3.3 und früher basieren.
Die CognitoAuthentication Erweiterungsbibliothek befindet sich in [Amazon.Extensions. CognitoAuthentication](https://www.nuget.org/packages/Amazon.Extensions.CognitoAuthentication/) NuGet Paket, vereinfacht den Authentifizierungsprozess von Amazon Cognito Cognito-Benutzerpools für .NET Core- und Xamarin-Entwickler. Die Bibliothek baut auf der Amazon Cognito Identity Provider-API auf, um API-Aufrufe zur Benutzerauthentifizierung zu erstellen und zu senden.
## Verwenden der CognitoAuthentication Erweiterungsbibliothek
Amazon Cognito verfügt über einige integrierte `AuthFlow` `ChallengeName` Werte für einen Standardauthentifizierungsablauf zur Validierung von Benutzername und Passwort über das Secure Remote Password (SRP). Weitere Informationen zum Authentifizierungsablauf finden Sie unter [Amazon Cognito Ablauf der Authentifizierung in Benutzerpools](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html).
Die folgenden Beispiele erfordern diese `using`-Anweisungen:
```
// Required for all examples
using System;
using Amazon;
using Amazon.CognitoIdentity;
using Amazon.CognitoIdentityProvider;
using Amazon.Extensions.CognitoAuthentication;
using Amazon.Runtime;
// Required for the GetS3BucketsAsync example
using Amazon.S3;
using Amazon.S3.Model;
```
### Verwenden Sie die Standardauthentifizierung
Erstellen Sie eine [AmazonCognitoIdentityProviderClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CognitoIdentityProvider/TCognitoIdentityProviderClient.html)mit [Anonym AWSCredentials](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Runtime/TAnonymousAWSCredentials.html), für die keine signierten Anfragen erforderlich sind. Sie müssen keine Region angeben. Der zugrunde liegende Code ruft `FallbackRegionFactory.GetRegionEndpoint()` auf, wenn keine Region angegeben ist. Erstellen Sie die Objekte `CognitoUserPool` und `CognitoUser`. Rufen Sie die Methode `StartWithSrpAuthAsync` mit einer `InitiateSrpAuthRequest` auf, in der das Benutzerpasswort enthalten ist.
```
public static async void GetCredsAsync()
{
AmazonCognitoIdentityProviderClient provider =
new AmazonCognitoIdentityProviderClient(new Amazon.Runtime.AnonymousAWSCredentials());
CognitoUserPool userPool = new CognitoUserPool("poolID", "clientID", provider);
CognitoUser user = new CognitoUser("username", "clientID", userPool, provider);
InitiateSrpAuthRequest authRequest = new InitiateSrpAuthRequest()
{
Password = "userPassword"
};
AuthFlowResponse authResponse = await user.StartWithSrpAuthAsync(authRequest).ConfigureAwait(false);
accessToken = authResponse.AuthenticationResult.AccessToken;
}
```
### Authentifizieren Sie sich bei Herausforderungen
Es ist auch einfacher, den Authentifizierungsfluss bei NewPasswordRequired Herausforderungen wie Multi-Factor Authentication (MFA) fortzusetzen. Die einzigen Anforderungen sind die CognitoAuthentication Objekte, das Benutzerkennwort für SRP und die erforderlichen Informationen für die nächste Herausforderung. Diese Informationen werden abgerufen, nachdem der Benutzer zur Eingabe aufgefordert wurde. Der folgende Code zeigt eine Möglichkeit, den Challenge-Typ zu überprüfen und die entsprechenden Antworten für MFA und NewPasswordRequired Challenges während des Authentifizierungsprozesses zu erhalten.
Führen Sie wie zuvor eine grundlegende Authentifizierung durch und geben Sie dann `await` für eine `AuthFlowResponse` aus. Wenn die Antwort empfangen wird, durchlaufen Sie das zurückgegebene `AuthenticationResult`-Objekt. Wenn der `ChallengeName`-Typ `NEW_PASSWORD_REQUIRED` ist, rufen Sie die Methode `RespondToNewPasswordRequiredAsync` auf.
```
public static async void GetCredsChallengesAsync()
{
AmazonCognitoIdentityProviderClient provider =
new AmazonCognitoIdentityProviderClient(new Amazon.Runtime.AnonymousAWSCredentials());
CognitoUserPool userPool = new CognitoUserPool("poolID", "clientID", provider);
CognitoUser user = new CognitoUser("username", "clientID", userPool, provider);
InitiateSrpAuthRequest authRequest = new InitiateSrpAuthRequest(){
Password = "userPassword"
};
AuthFlowResponse authResponse = await user.StartWithSrpAuthAsync(authRequest).ConfigureAwait(false);
while (authResponse.AuthenticationResult == null)
{
if (authResponse.ChallengeName == ChallengeNameType.NEW_PASSWORD_REQUIRED)
{
Console.WriteLine("Enter your desired new password:");
string newPassword = Console.ReadLine();
authResponse = await user.RespondToNewPasswordRequiredAsync(new RespondToNewPasswordRequiredRequest()
{
SessionID = authResponse.SessionID,
NewPassword = newPassword
});
accessToken = authResponse.AuthenticationResult.AccessToken;
}
else if (authResponse.ChallengeName == ChallengeNameType.SMS_MFA)
{
Console.WriteLine("Enter the MFA Code sent to your device:");
string mfaCode = Console.ReadLine();
AuthFlowResponse mfaResponse = await user.RespondToSmsMfaAuthAsync(new RespondToSmsMfaRequest()
{
SessionID = authResponse.SessionID,
MfaCode = mfaCode
}).ConfigureAwait(false);
accessToken = authResponse.AuthenticationResult.AccessToken;
}
else
{
Console.WriteLine("Unrecognized authentication challenge.");
accessToken = "";
break;
}
}
if (authResponse.AuthenticationResult != null)
{
Console.WriteLine("User successfully authenticated.");
}
else
{
Console.WriteLine("Error in authentication process.");
}
}
```
### Verwenden Sie AWS Ressourcen nach der Authentifizierung
Sobald ein Benutzer mithilfe der CognitoAuthentication Bibliothek authentifiziert wurde, besteht der nächste Schritt darin, dem Benutzer den Zugriff auf die entsprechenden AWS Ressourcen zu ermöglichen. Dazu müssen Sie über die Amazon Cognito Federated Identities-Konsole einen Identitätspool erstellen. Indem Sie den Amazon Cognito Cognito-Benutzerpool, den Sie als Anbieter erstellt haben, mithilfe seiner PoolID und ClientID angeben, können Sie den Benutzern Ihres Amazon Cognito Cognito-Benutzerpools den Zugriff auf AWS Ressourcen ermöglichen, die mit Ihrem Konto verbunden sind. Sie können auch unterschiedliche Rollen für authentifizierte und nicht authentifizierte Benutzer angeben, um so Zugriff auf unterschiedliche Ressourcen zu ermöglichen. Sie können diese Regeln in der IAM-Konsole ändern. Hier können Sie im Feld **Aktion** der an die Richtlinie angefügten Rolle Berechtigungen hinzufügen oder entfernen. Anschließend können Sie mithilfe des entsprechenden Identitätspools, Benutzerpools und Amazon Cognito Cognito-Benutzerinformationen Aufrufe an verschiedene AWS Ressourcen tätigen. Das folgende Beispiel zeigt einen Benutzer, der bei SRP authentifiziert ist und auf die verschiedenen Amazon S3 S3-Buckets zugreift, die durch die Rolle des zugehörigen Identitätspools zugelassen sind.
```
public async void GetS3BucketsAsync()
{
var provider = new AmazonCognitoIdentityProviderClient(new AnonymousAWSCredentials());
CognitoUserPool userPool = new CognitoUserPool("poolID", "clientID", provider);
CognitoUser user = new CognitoUser("username", "clientID", userPool, provider);
string password = "userPassword";
AuthFlowResponse context = await user.StartWithSrpAuthAsync(new InitiateSrpAuthRequest()
{
Password = password
}).ConfigureAwait(false);
CognitoAWSCredentials credentials =
user.GetCognitoAWSCredentials("identityPoolID", RegionEndpoint.< YourIdentityPoolRegion >);
using (var client = new AmazonS3Client(credentials))
{
ListBucketsResponse response =
await client.ListBucketsAsync(new ListBucketsRequest()).ConfigureAwait(false);
foreach (S3Bucket bucket in response.Buckets)
{
Console.WriteLine(bucket.BucketName);
}
}
}
```
## Weitere Authentifizierungsoptionen
Zusätzlich zu SRP NewPasswordRequired, und MFA bietet die CognitoAuthentication Erweiterungsbibliothek einen einfacheren Authentifizierungsablauf für:
+ Custom – Initiiert durch einen Aufruf an `StartWithCustomAuthAsync(InitiateCustomAuthRequest customRequest)`
+ RefreshToken - Initiieren Sie mit einem Anruf an `StartWithRefreshTokenAuthAsync(InitiateRefreshTokenAuthRequest refreshTokenRequest)`
+ RefreshTokenSRP — Initiieren Sie mit einem Anruf an `StartWithRefreshTokenAuthAsync(InitiateRefreshTokenAuthRequest refreshTokenRequest)`
+ AdminNoSRP — Initiieren Sie mit einem Anruf an `StartWithAdminNoSrpAuthAsync(InitiateAdminNoSrpAuthRequest adminAuthRequest)`
Rufen Sie abhängig vom gewünschten Ablauf die entsprechende Methode auf. Fahren Sie dann mit Eingabeaufforderungen an den Benutzer fort, die ihm in den `AuthFlowResponse`-Objekten eines jeden Methodenaufrufs angezeigt werden. Rufen Sie außerdem die entsprechende Antwortmethode, wie z. B. `RespondToSmsMfaAuthAsync` für MFA-Aufforderungen und `RespondToCustomAuthAsync` für benutzerdefinierte Aufforderungen, auf.
# Verwenden von Amazon DynamoDB NoSQL-Datenbanken
**Anmerkung**
Die Programmiermodelle in diesen Themen sind sowohl in.NET Framework als auch in .NET (Core) vorhanden, aber die Aufrufkonventionen unterscheiden sich, unabhängig davon, ob sie synchron oder asynchron sind.
Der AWS SDK für .NET unterstützt Amazon DynamoDB, einen schnellen NoSQL-Datenbankservice, der von angeboten wird. AWS Das SDK bietet drei Programmiermodelle für die Kommunikation mit DynamoDB: das *Low-Level-Modell*, das *Dokumentenmodell* und das *Objektpersistenzmodell*.
Die folgenden Informationen stellen diese und ihre Modelle vor APIs, enthalten Beispiele dafür, wie und wann sie zu verwenden sind, und enthalten Links zu zusätzlichen DynamoDB-Programmierressourcen in der. AWS SDK für .NET
## Low-Level-Modell
Das Low-Level-Programmiermodell umschließt direkte Aufrufe an den DynamoDB-Dienst. [Sie greifen über den Amazon.Dynamo-Namespace auf dieses Modell zu. DBv2](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/NDynamoDBv2.html)
Von den drei Modellen müssen Sie für das Low-Level-Modell den meisten Code schreiben. Beispielsweise müssen Sie.NET-Datentypen in ihre Entsprechungen in DynamoDB konvertieren. Allerdings bietet Ihnen dieses Modell Zugriff auf die meisten Funktionen.
Die folgenden Beispiele zeigen, wie Sie das Low-Level-Modell verwenden, um eine Tabelle zu erstellen, eine Tabelle zu ändern und Elemente in eine Tabelle in DynamoDB einzufügen.
### Erstellen einer Tabelle
Im folgenden Beispiel erstellen Sie eine Tabelle mithilfe der `CreateTable`-Methode der Klasse `AmazonDynamoDBClient`. Die `CreateTable`-Methode verwendet eine Instance der `CreateTableRequest`-Klasse, die Merkmale wie erforderliche Elementattributnamen, Primärschlüsseldefinition und Durchsatzkapazität enthält. Die `CreateTable`-Methode gibt eine Instance der `CreateTableResponse`-Klasse zurück.
```
// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;
var client = new AmazonDynamoDBClient();
Console.WriteLine("Getting list of tables");
List currentTables = client.ListTables().TableNames;
Console.WriteLine("Number of tables: " + currentTables.Count);
if (!currentTables.Contains("AnimalsInventory"))
{
var request = new CreateTableRequest
{
TableName = "AnimalsInventory",
AttributeDefinitions = new List
{
new AttributeDefinition
{
AttributeName = "Id",
// "S" = string, "N" = number, and so on.
AttributeType = "N"
},
new AttributeDefinition
{
AttributeName = "Type",
AttributeType = "S"
}
},
KeySchema = new List
{
new KeySchemaElement
{
AttributeName = "Id",
// "HASH" = hash key, "RANGE" = range key.
KeyType = "HASH"
},
new KeySchemaElement
{
AttributeName = "Type",
KeyType = "RANGE"
},
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 10,
WriteCapacityUnits = 5
},
};
var response = client.CreateTable(request);
Console.WriteLine("Table created with request ID: " +
response.ResponseMetadata.RequestId);
}
```
### Überprüfen, ob eine Tabelle für Änderungen bereit ist
Bevor Sie eine Tabelle ändern oder modifizieren können, muss die Tabelle für die Änderung bereit stehen. Das folgende Beispiel zeigt, wie das Low-Level-Modell verwendet wird, um zu überprüfen, ob eine Tabelle in DynamoDB bereit ist. In diesem Beispiel wird die zu überprüfende Zieltabelle durch die `DescribeTable`-Methode der `AmazonDynamoDBClient`-Klasse referenziert. Alle fünf Sekunden überprüft der Code den Wert der `TableStatus`-Eigenschaft der Tabelle. Sobald der Status auf `ACTIVE` gesetzt wird, steht die Tabelle zum Ändern bereit.
```
// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;
var client = new AmazonDynamoDBClient();
var status = "";
do
{
// Wait 5 seconds before checking (again).
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(5));
try
{
var response = client.DescribeTable(new DescribeTableRequest
{
TableName = "AnimalsInventory"
});
Console.WriteLine("Table = {0}, Status = {1}",
response.Table.TableName,
response.Table.TableStatus);
status = response.Table.TableStatus;
}
catch (ResourceNotFoundException)
{
// DescribeTable is eventually consistent. So you might
// get resource not found.
}
} while (status != TableStatus.ACTIVE);
```
### Einfügen eines Elements in eine Tabelle
Im folgenden Beispiel verwenden Sie das Low-Level-Modell, um zwei Elemente in eine Tabelle in DynamoDB einzufügen. Jedes Element wird durch die `PutItem`-Methode der `AmazonDynamoDBClient`-Klasse mithilfe einer Instance der `PutItemRequest`-Klasse eingefügt. Jede der beiden Instances der `PutItemRequest`-Klasse akzeptiert den Namen der Tabelle, in die die Elemente eingefügt werden, sowie eine Reihe von Elementattributwerten.
```
// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;
var client = new AmazonDynamoDBClient();
var request1 = new PutItemRequest
{
TableName = "AnimalsInventory",
Item = new Dictionary
{
{ "Id", new AttributeValue { N = "1" }},
{ "Type", new AttributeValue { S = "Dog" }},
{ "Name", new AttributeValue { S = "Fido" }}
}
};
var request2 = new PutItemRequest
{
TableName = "AnimalsInventory",
Item = new Dictionary
{
{ "Id", new AttributeValue { N = "2" }},
{ "Type", new AttributeValue { S = "Cat" }},
{ "Name", new AttributeValue { S = "Patches" }}
}
};
client.PutItem(request1);
client.PutItem(request2);
```
## Dokument-Modell
Das Modell der Dokumentenprogrammierung bietet eine einfachere Möglichkeit, mit Daten in DynamoDB zu arbeiten. Dieses Modell ist speziell für den Zugriff auf Tabellen und Elemente in Tabellen vorgesehen. [Sie greifen über Amazon.Dynamo auf dieses Modell zu. DBv2 DocumentModel](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/NDynamoDBv2DocumentModel.html)Namespace.
Im Vergleich zum Low-Level-Programmiermodell ist das Dokumentmodell einfacher anhand von DynamoDB-Daten zu codieren. Sie müssen beispielsweise nicht so viele .NET-Datentypen in ihre Entsprechungen in DynamoDB konvertieren. Allerdings bietet dieses Modell auf weniger Funktionen Zugriff als das Low-Level-Programmierungsmodell. Mit diesem Modell können Sie beispielsweise Elemente in Tabellen erstellen, abrufen, aktualisieren und löschen. Zum Erstellen der Tabellen müssen Sie jedoch das Low-Level-Modell verwenden. Im Vergleich zum Object Persistence-Modell müssen Sie bei diesem Modell zum Speichern, Laden und Abfragen von .NET-Objekten mehr Code schreiben.
Weitere Informationen zum DynamoDB-Dokumentprogrammiermodell finden Sie [unter.NET: Document Model](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKMidLevel.html) im [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/) Developer Guide.
Die folgenden Abschnitte enthalten Informationen zum Erstellen einer Darstellung der gewünschten DynamoDB-Tabelle sowie Beispiele zur Verwendung des Dokumentmodells zum Einfügen von Elementen in Tabellen und zum Abrufen von Elementen aus Tabellen.
### Erstellen Sie eine Darstellung der Tabelle
Um Datenoperationen mithilfe des Dokumentmodells durchzuführen, müssen Sie zunächst eine Instanz der `Table` Klasse erstellen, die eine bestimmte Tabelle darstellt. Dafür gibt es hauptsächlich zwei Möglichkeiten.
**LoadTable Methode**
Der erste Mechanismus besteht darin, eine der statischen `LoadTable` Methoden der [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/TTable.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/TTable.html)Klasse zu verwenden, ähnlich dem folgenden Beispiel:
```
var client = new AmazonDynamoDBClient();
Table table = Table.LoadTable(client, "Reply");
```
**Anmerkung**
Dieser Mechanismus funktioniert zwar, kann aber unter bestimmten Bedingungen aufgrund von Kaltstart- und Threadpool-Verhalten manchmal zu zusätzlicher Latenz oder Deadlocks führen. Weitere Informationen zu diesen Verhaltensweisen finden Sie im Blogbeitrag [Verbesserte DynamoDB-Initialisierungsmuster](https://aws.amazon.com/blogs/developer/improved-dynamodb-initialization-patterns-for-the-aws-sdk-for-net/) für den. AWS SDK für .NET
**TableBuilder**
Ein alternativer Mechanismus, die [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/TTableBuilder.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/TTableBuilder.html)Klasse, wurde in [Version 3.7.203](https://www.nuget.org/packages/AWSSDK.DynamoDBv2/3.7.203) des .Dynamo-Pakets eingeführt. AWSSDK DBv2 NuGet Mit diesem Mechanismus können die oben genannten Verhaltensweisen behoben werden, indem bestimmte implizite Methodenaufrufe, insbesondere die Methode, entfernt werden. `DescribeTable` Dieser Mechanismus wird ähnlich wie im folgenden Beispiel verwendet:
```
var client = new AmazonDynamoDBClient();
var table = new TableBuilder(client, "Reply")
.AddHashKey("Id", DynamoDBEntryType.String)
.AddRangeKey("ReplyDateTime", DynamoDBEntryType.String)
.AddGlobalSecondaryIndex("PostedBy-Message-index", "Author", DynamoDBEntryType.String, "Message", DynamoDBEntryType.String)
.Build();
```
Weitere Informationen zu diesem alternativen Mechanismus finden Sie erneut im Blogbeitrag [Verbesserte DynamoDB-Initialisierungsmuster](https://aws.amazon.com/blogs/developer/improved-dynamodb-initialization-patterns-for-the-aws-sdk-for-net/) für die. AWS SDK für .NET
### Ein Element in eine Tabelle einfügen
Im folgenden Beispiel wird eine Antwort mithilfe der `PutItemAsync` Methode der `Table` Klasse in die Antworttabelle eingefügt. Die `PutItemAsync`-Methode übernimmt eine Instance der `Document`-Klasse, wobei die `Document`-Klasse einfach eine Sammlung von initialisierten Attributen ist.
```
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DocumentModel;
// Create a representation of the "Reply" table
// by using one of the mechanisms described previously.
// Then, add a reply to the table.
var newReply = new Document();
newReply["Id"] = Guid.NewGuid().ToString();
newReply["ReplyDateTime"] = DateTime.UtcNow;
newReply["PostedBy"] = "Author1";
newReply["Message"] = "Thank you!";
await table.PutItemAsync(newReply);
```
### Ein Element aus einer Tabelle abrufen
Im folgenden Beispiel wird eine Antwort über die `GetItemAsync` Methode der `Table` Klasse abgerufen. Um zu ermitteln, welche Antwort abgerufen werden soll, verwendet die `GetItemAsync` Methode den hash-and-range Primärschlüssel der Zielantwort.
```
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DocumentModel;
// Create a representation of the "Reply" table
// by using one of the mechanisms described previously.
// Then, get a reply from the table
// where "guid" is the hash key and "datetime" is the range key.
var reply = await table.GetItemAsync(guid, datetime);
Console.WriteLine("Id = " + reply["Id"]);
Console.WriteLine("ReplyDateTime = " + reply["ReplyDateTime"]);
Console.WriteLine("PostedBy = " + reply["PostedBy"]);
Console.WriteLine("Message = " + reply["Message"]);
```
Im vorherigen Beispiel werden die Tabellenwerte implizit in Zeichenketten für die `WriteLine` Methode konvertiert. Sie können explizite Konvertierungen durchführen, indem Sie die verschiedenen „As [type]“ -Methoden der `DynamoDBEntry` Klasse verwenden. Beispielsweise können Sie den Wert für mit der folgenden `AsGuid()` Methode explizit `Id` von einem `Primitive` Datentyp in eine GUID konvertieren:
```
var guid = reply["Id"].AsGuid();
```
## Object Persistence-Modell
Das Objektpersistenz-Programmiermodell wurde speziell für das Speichern, Laden und Abfragen von .NET-Objekten in DynamoDB entwickelt. [Sie greifen über Amazon.Dynamo auf dieses Modell zu. DBv2 DataModel](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/NDynamoDBv2DataModel.html)Namespace.
Von den drei Modellen ist das Objektpersistenzmodell am einfachsten zu verwenden, wenn Sie DynamoDB-Daten speichern, laden oder abfragen. Sie arbeiten beispielsweise direkt mit DynamoDB-Datentypen. Dieses Modell bietet jedoch nur Zugriff auf Operationen, die .NET-Objekte in DynamoDB speichern, laden und abfragen. Mit diesem Modell können Sie beispielsweise Elemente in Tabellen erstellen, abrufen, aktualisieren und löschen. Sie müssen jedoch zunächst die Tabellen mithilfe des Low-Level-Modells erstellen und dann dieses Modell verwenden, um die .NET-Klassen den Tabellen zuzuordnen.
Weitere Informationen zum DynamoDB-Programmiermodell für Objektpersistenz finden Sie [unter.NET: Object persistence model](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKHighLevel.html) im [Amazon](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/) DynamoDB Developer Guide.
Die folgenden Beispiele zeigen, wie Sie eine .NET-Klasse definieren, die ein DynamoDB-Element darstellt, eine Instanz der .NET-Klasse verwenden, um ein Element in eine DynamoDB-Tabelle einzufügen, und wie Sie eine Instanz der .NET-Klasse verwenden, um ein Element aus der Tabelle abzurufen.
### Definieren einer .NET-Klasse, die ein Element in einer Tabelle darstellt
Im folgenden Beispiel für eine Klassendefinition gibt das `DynamoDBTable` Attribut den Tabellennamen an, während die `DynamoDBRangeKey` Attribute `DynamoDBHashKey` und den hash-and-range Primärschlüssel der Tabelle modellieren. Das `DynamoDBGlobalSecondaryIndexHashKey` Attribut ist so definiert, dass eine Abfrage nach Antworten eines bestimmten Autors erstellt werden kann.
```
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;
[DynamoDBTable("Reply")]
public class Reply
{
[DynamoDBHashKey]
public string Id { get; set; }
[DynamoDBRangeKey(StoreAsEpoch = false)]
public DateTime ReplyDateTime { get; set; }
[DynamoDBGlobalSecondaryIndexHashKey("PostedBy-Message-Index",
AttributeName ="PostedBy")]
public string Author { get; set; }
[DynamoDBGlobalSecondaryIndexRangeKey("PostedBy-Message-Index")]
public string Message { get; set; }
}
```
### Erstellen eines Kontextes für das Objektpersistenzmodell
Um das Objektpersistenz-Programmiermodell für DynamoDB zu verwenden, müssen Sie einen Kontext erstellen, der eine Verbindung zu DynamoDB bereitstellt und es Ihnen ermöglicht, auf Tabellen zuzugreifen, verschiedene Operationen durchzuführen und Abfragen auszuführen.
**Grundlegender Kontext**
Das folgende Beispiel zeigt, wie der einfachste Kontext erstellt wird.
```
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;
var client = new AmazonDynamoDBClient();
var context = new DynamoDBContext(client);
```
**Kontext mit DisableFetchingTableMetadata Eigentum**
Das folgende Beispiel zeigt, wie Sie zusätzlich die `DisableFetchingTableMetadata` Eigenschaft der `DynamoDBContextConfig` Klasse festlegen können, um implizite Aufrufe der `DescribeTable` Methode zu verhindern.
```
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;
var client = new AmazonDynamoDBClient();
var context = new DynamoDBContext(client, new DynamoDBContextConfig
{
DisableFetchingTableMetadata = true
});
```
Wenn die `DisableFetchingTableMetadata` Eigenschaft auf `false` (Standard) gesetzt ist, wie im ersten Beispiel gezeigt, können Sie Attribute, die die Schlüssel- und Indexstruktur von Tabellenelementen beschreiben, aus der `Reply` Klasse weglassen. Diese Attribute werden stattdessen durch einen impliziten Aufruf der Methode abgeleitet. `DescribeTable` Sie `DisableFetchingTableMetadata` ist`true`, wie im zweiten Beispiel gezeigt, auf Methoden des Objektpersistenzmodells gesetzt, die ausschließlich auf den in der Klasse definierten Attributen `QueryAsync` basieren. `SaveAsync` `Reply` In diesem Fall erfolgt kein Aufruf der `DescribeTable` Methode.
**Anmerkung**
Unter bestimmten Bedingungen können Aufrufe der `DescribeTable` Methode aufgrund von Kaltstart- und Threadpool-Verhalten manchmal zu zusätzlicher Latenz oder Deadlocks führen. Aus diesem Grund ist es manchmal vorteilhaft, Aufrufe dieser Methode zu vermeiden.
Weitere Informationen zu diesen Verhaltensweisen finden Sie im Blogbeitrag [Verbesserte DynamoDB-Initialisierungsmuster](https://aws.amazon.com/blogs/developer/improved-dynamodb-initialization-patterns-for-the-aws-sdk-for-net/) für den. AWS SDK für .NET
### Verwenden einer Instanz der .NET-Klasse zum Einfügen eines Elements in eine Tabelle
In diesem Beispiel wird ein Element über die `SaveAsync` Methode der `DynamoDBContext` Klasse eingefügt, die eine initialisierte Instanz der .NET-Klasse verwendet, die das Element darstellt.
```
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;
// Create an appropriate context for the object persistence programming model,
// examples of which have been described earlier.
// Create an object that represents the new item.
var reply = new Reply()
{
Id = Guid.NewGuid().ToString(),
ReplyDateTime = DateTime.UtcNow,
Author = "Author1",
Message = "Thank you!"
};
// Insert the item into the table.
await context.SaveAsync(reply, new DynamoDBOperationConfig
{
IndexName = "PostedBy-Message-index"
});
```
### Verwenden einer Instanz einer .NET-Klasse, um Elemente aus einer Tabelle abzurufen
In diesem Beispiel wird eine Abfrage erstellt, um alle Datensätze von „Author1" mithilfe der `QueryAsync` Methode der `DynamoDBContext` Klasse zu finden. Anschließend werden die Elemente mit der `GetNextSetAsync` Methode der Abfrage abgerufen.
```
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;
// Create an appropriate context for the object persistence programming model,
// examples of which have been described earlier.
// Construct a query that finds all replies by a specific author.
var query = context.QueryAsync("Author1", new DynamoDBOperationConfig
{
IndexName = "PostedBy-Message-index"
});
// Display the result.
var set = await query.GetNextSetAsync();
foreach (var item in set)
{
Console.WriteLine("Id = " + item.Id);
Console.WriteLine("ReplyDateTime = " + item.ReplyDateTime);
Console.WriteLine("PostedBy = " + item.Author);
Console.WriteLine("Message = " + item.Message);
}
```
### Zusätzliche Informationen zum Objektpersistenzmodell
Die oben gezeigten Beispiele und Erläuterungen beinhalten manchmal eine Eigenschaft der `DisableFetchingTableMetadata` aufgerufenen `DynamoDBContext` Klasse. Diese Eigenschaft, die in [Version 3.7.203 des AWSSDK DBv2 NuGet .Dynamo-Pakets eingeführt wurde, ermöglicht es Ihnen, bestimmte Bedingungen zu vermeiden, die](https://www.nuget.org/packages/AWSSDK.DynamoDBv2/3.7.203) aufgrund von Kaltstart- und Threadpool-Verhalten zu zusätzlichen Latenzen oder Deadlocks führen könnten. Weitere Informationen finden Sie im Blogbeitrag [Verbesserte DynamoDB-Initialisierungsmuster](https://aws.amazon.com/blogs/developer/improved-dynamodb-initialization-patterns-for-the-aws-sdk-for-net/) für. AWS SDK für .NET
Im Folgenden finden Sie einige zusätzliche Informationen zu dieser Eigenschaft.
+ Diese Eigenschaft kann global in Ihrer `app.config` `web.config` OR-Datei festgelegt werden, wenn Sie.NET Framework verwenden.
+ Diese Eigenschaft kann mithilfe der [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigsDynamoDB.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigsDynamoDB.html)Klasse global festgelegt werden, wie im folgenden Beispiel gezeigt.
```
// Set the DisableFetchingTableMetadata property globally
// before constructing any context objects.
AWSConfigsDynamoDB.Context.DisableFetchingTableMetadata = true;
var client = new AmazonDynamoDBClient();
var context = new DynamoDBContext(client);
```
+ In einigen Fällen können Sie einer .NET-Klasse keine DynamoDB-Attribute hinzufügen, z. B. wenn die Klasse in einer Abhängigkeit definiert ist. In solchen Fällen ist es dennoch möglich, die Eigenschaft zu nutzen. `DisableFetchingTableMetadata` Verwenden Sie dazu zusätzlich zur `DisableFetchingTableMetadata` Eigenschaft die [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/TTableBuilder.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/DynamoDBv2/TTableBuilder.html)Klasse. Die `TableBuilder` Klasse wurde auch in [Version 3.7.203 des AWSSDK DBv2 NuGet .Dynamo-Pakets](https://www.nuget.org/packages/AWSSDK.DynamoDBv2/3.7.203) eingeführt.
```
// Set the DisableFetchingTableMetadata property globally
// before constructing any context objects.
AWSConfigsDynamoDB.Context.DisableFetchingTableMetadata = true;
var client = new AmazonDynamoDBClient();
var context = new DynamoDBContext(client);
var table = new TableBuilder(client, "Reply")
.AddHashKey("Id", DynamoDBEntryType.String)
.AddRangeKey("ReplyDateTime", DynamoDBEntryType.String)
.AddGlobalSecondaryIndex("PostedBy-Message-index", "Author", DynamoDBEntryType.String,
"Message", DynamoDBEntryType.String)
.Build();
// This registers the "Reply" table we constructed via the builder.
context.RegisterTableDefinition(table);
// Now operations like this will work,
// even if the Reply class was not annotated with this index.
var query = context.QueryAsync("Author1", new DynamoDBOperationConfig()
{
IndexName = "PostedBy-Message-index"
});
```
## Weitere Informationen
**Verwendung von DynamoDB AWS SDK für .NET zum Programmieren, Informationen und Beispiele**
+ [DynamoDB APIs](http://blogs.aws.amazon.com/net/post/Tx17SQHVEMW8MXC/DynamoDB-APIs)
+ [DynamoDB Series Kickoff](http://blogs.aws.amazon.com/net/post/Tx2XQOCY08QMTKO/DynamoDB-Series-Kickoff)
+ [DynamoDB Series - Document Model](http://blogs.aws.amazon.com/net/post/Tx2R0WG46GQI1JI/DynamoDB-Series-Document-Model)
+ [DynamoDB Series - Conversion Schemas](http://blogs.aws.amazon.com/net/post/Tx2TCOGWG7ARUH5/DynamoDB-Series-Conversion-Schemas)
+ [DynamoDB Series - Object Persistence Model](http://blogs.aws.amazon.com/net/post/Tx20L86FLMBW51P/DynamoDB-Series-Object-Persistence-Model)
+ [DynamoDB Series - Expressions](http://blogs.aws.amazon.com/net/post/TxZQM7VA9AUZ9L/DynamoDB-Series-Expressions)
+ [Verwenden von Ausdrücken mit Amazon DynamoDB und AWS SDK für .NET](dynamodb-expressions.md)
+ [JSON-Unterstützung in Amazon DynamoDB](dynamodb-json.md)
**Low-Level-Modell, Informationen und Beispiele**
+ [Arbeiten mit Tabellen mithilfe der AWS SDK für .NET Low-Level-API](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetWorkingWithTables.html)
+ [Mit Elementen arbeiten, die die AWS SDK für .NET Low-Level-API verwenden](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetItemCRUD.html)
+ [Abfragen von Tabellen mithilfe der Low-Level-API AWS SDK für .NET](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetQuerying.html)
+ [Scannen von Tabellen mithilfe der AWS SDK für .NET Low-Level-API](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetScanning.html)
+ [Arbeiten mit lokalen Sekundärindizes mithilfe der AWS SDK für .NET Low-Level-API](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LSILowLevelDotNet.html)
+ [Arbeiten mit globalen Sekundärindizes mithilfe der Low-Level-API AWS SDK für .NET](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSILowLevelDotNet.html)
**Dokumentenmodell, Informationen und Beispiele**
+ [DynamoDB-Datentypen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataModel.html#DataModel.DataTypes)
+ [Dynamo DBEntry](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/TDynamoDBv2DocumentModelDynamoDBEntry.html)
+ [.NET: Dokumentmodell](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKMidLevel.html)
**Modell, Informationen und Beispiele für Objektpersistenz**
+ [.NET: "Object Persistence"-Modell](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKHighLevel.html)
**Weitere nützliche Informationen**
+ Informationen [Integration AWS mit.NET Aspire](aspire-integrations.md) zur lokalen Entwicklung mit Amazon DynamoDB über.NET Aspire finden Sie unter.
**Topics**
+ [Low-Level-Modell](#dynamodb-intro-apis-low-level)
+ [Dokument-Modell](#dynamodb-intro-apis-document)
+ [Object Persistence-Modell](#dynamodb-intro-apis-object-persistence)
+ [Weitere Informationen](#dynamodb-intro-more-info)
+ [Verwenden von Ausdrücken](dynamodb-expressions.md)
+ [JSON-Support](dynamodb-json.md)
# Verwenden von Ausdrücken mit Amazon DynamoDB und AWS SDK für .NET
**Anmerkung**
Die Informationen in diesem Thema beziehen sich speziell auf Projekte, die auf .NET Framework und AWS SDK für .NET Version 3.3 und früher basieren.
Die folgenden Codebeispiele zeigen, wie Sie DynamoDB mit Ausdrücken programmieren. AWS SDK für .NET *Ausdrücke* bezeichnen die Attribute, die Sie aus einem Element in einer DynamoDB-Tabelle lesen möchten. Sie können auch Ausdrücke beim Schreiben eines Elements verwenden, um alle zu erfüllenden Bedingungen (*bedingte Aktualisierung*) und die Art, wie die Attribute aktualisiert werden, anzugeben. In einigen Beispielen zur Aktualisierung wird das Attribut durch einen neuen Wert ersetzt oder es werden einer Liste bzw. einer Map neue Daten hinzugefügt. Weitere Informationen finden Sie unter [Reading and Writing Items Using Expressions](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.html).
**Topics**
+ [Beispieldaten](#dynamodb-expressions-sample-data)
+ [Abrufen eines einzelnen Elements mithilfe von Ausdrücken und dem Primärschlüssel des Elements](#dynamodb-expressions-get-item)
+ [Abrufen von mehreren Elementen mithilfe von Ausdrücken und dem Primärschlüssel der Tabelle](#dynamodb-expressions-query)
+ [Abrufen von mehreren Elementen mithilfe von Ausdrücken und anderen Element-Attributen](#dynamodb-expressions-scan)
+ [Drucken eines Elements](#dynamodb-expressions-print-item)
+ [Erstellen oder Ersetzen eines Elements mithilfe von Ausdrücken](#dynamodb-expressions-put-item)
+ [Aktualisieren eines Elements mithilfe von Ausdrücken](#dynamodb-expressions-update-item)
+ [Löschen eines Elements mithilfe von Ausdrücken](#dynamodb-expressions-delete-item)
+ [Weitere Infos](#dynamodb-expressions-resources)
## Beispieldaten
Die Codebeispiele in diesem Thema basieren auf den folgenden beiden Beispielelementen in einer DynamoDB-Tabelle mit dem Namen. `ProductCatalog` Diese Elemente beschreiben Informationen über Produkteinträge im Katalog eines fiktiven Fahrradgeschäftes. Diese Elemente basieren auf dem Beispiel in [Case Study: A ProductCatalog ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.CaseStudy.html) Item. Die Datentypbeschreibungen wie `BOOL`, `L`, `M`, `N`, `NS`, `S` und `SS` entsprechen jenen im [JSON-Datenformat](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataFormat.html).
```
{
"Id": {
"N": "205"
},
"Title": {
"S": "20-Bicycle 205"
},
"Description": {
"S": "205 description"
},
"BicycleType": {
"S": "Hybrid"
},
"Brand": {
"S": "Brand-Company C"
},
"Price": {
"N": "500"
},
"Gender": {
"S": "B"
},
"Color": {
"SS": [
"Red",
"Black"
]
},
"ProductCategory": {
"S": "Bike"
},
"InStock": {
"BOOL": true
},
"QuantityOnHand": {
"N": "1"
},
"RelatedItems": {
"NS": [
"341",
"472",
"649"
]
},
"Pictures": {
"L": [
{
"M": {
"FrontView": {
"S": "http://example/products/205_front.jpg"
}
}
},
{
"M": {
"RearView": {
"S": "http://example/products/205_rear.jpg"
}
}
},
{
"M": {
"SideView": {
"S": "http://example/products/205_left_side.jpg"
}
}
}
]
},
"ProductReviews": {
"M": {
"FiveStar": {
"SS": [
"Excellent! Can't recommend it highly enough! Buy it!",
"Do yourself a favor and buy this."
]
},
"OneStar": {
"SS": [
"Terrible product! Do not buy this."
]
}
}
}
},
{
"Id": {
"N": "301"
},
"Title": {
"S": "18-Bicycle 301"
},
"Description": {
"S": "301 description"
},
"BicycleType": {
"S": "Road"
},
"Brand": {
"S": "Brand-Company C"
},
"Price": {
"N": "185"
},
"Gender": {
"S": "F"
},
"Color": {
"SS": [
"Blue",
"Silver"
]
},
"ProductCategory": {
"S": "Bike"
},
"InStock": {
"BOOL": true
},
"QuantityOnHand": {
"N": "3"
},
"RelatedItems": {
"NS": [
"801",
"822",
"979"
]
},
"Pictures": {
"L": [
{
"M": {
"FrontView": {
"S": "http://example/products/301_front.jpg"
}
}
},
{
"M": {
"RearView": {
"S": "http://example/products/301_rear.jpg"
}
}
},
{
"M": {
"SideView": {
"S": "http://example/products/301_left_side.jpg"
}
}
}
]
},
"ProductReviews": {
"M": {
"FiveStar": {
"SS": [
"My daughter really enjoyed this bike!"
]
},
"ThreeStar": {
"SS": [
"This bike was okay, but I would have preferred it in my color.",
"Fun to ride."
]
}
}
}
}
```
## Abrufen eines einzelnen Elements mithilfe von Ausdrücken und dem Primärschlüssel des Elements
Im folgenden Beispiel werden die `Amazon.DynamoDBv2.AmazonDynamoDBClient.GetItem`-Methode sowie eine Gruppe von Ausdrücken zum Abrufen und anschließenden Drucken des Elements mit einer `Id` von `205` veranschaulicht. Es werden nur die folgenden Attribute des Elements zurückgegeben: `Id`, `Title`, `Description`, `Color`, `RelatedItems`, `Pictures` und `ProductReviews`.
```
// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;
var client = new AmazonDynamoDBClient();
var request = new GetItemRequest
{
TableName = "ProductCatalog",
ProjectionExpression = "Id, Title, Description, Color, #ri, Pictures, #pr",
ExpressionAttributeNames = new Dictionary
{
{ "#pr", "ProductReviews" },
{ "#ri", "RelatedItems" }
},
Key = new Dictionary
{
{ "Id", new AttributeValue { N = "205" } }
},
};
var response = client.GetItem(request);
// PrintItem() is a custom function.
PrintItem(response.Item);
```
Im vorangegangenen Beispiel gibt die `ProjectionExpression`-Eigenschaft die zurückzugebenden Attribute an. Die `ExpressionAttributeNames`-Eigenschaft gibt den Platzhalter `#pr` an, der das `ProductReviews`-Attribut repräsentiert sowie den Platzhalter `#ri`, der für das `RelatedItems`-Attribut steht. Das Aufrufen von `PrintItem` bezieht sich auf eine benutzerdefinierte Funktion, wie unter [Drucken eines Elements](#dynamodb-expressions-print-item) beschrieben.
## Abrufen von mehreren Elementen mithilfe von Ausdrücken und dem Primärschlüssel der Tabelle
Im folgenden Beispiel werden die `Amazon.DynamoDBv2.AmazonDynamoDBClient.Query`-Methode sowie eine Gruppe von Ausdrücken zum Abrufen und anschließenden Drucken des Elements mit einer `Id` von `301`, jedoch nur, wenn der Wert von `Price` größer als `150` ist, veranschaulicht. Es werden nur die folgenden Attribute des Elements zurückgegeben: `Id`, `Title` sowie sämtliche `ThreeStar`-Attribute in `ProductReviews`.
```
// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;
var client = new AmazonDynamoDBClient();
var request = new QueryRequest
{
TableName = "ProductCatalog",
KeyConditions = new Dictionary
{
{ "Id", new Condition()
{
ComparisonOperator = ComparisonOperator.EQ,
AttributeValueList = new List
{
new AttributeValue { N = "301" }
}
}
}
},
ProjectionExpression = "Id, Title, #pr.ThreeStar",
ExpressionAttributeNames = new Dictionary
{
{ "#pr", "ProductReviews" },
{ "#p", "Price" }
},
ExpressionAttributeValues = new Dictionary
{
{ ":val", new AttributeValue { N = "150" } }
},
FilterExpression = "#p > :val"
};
var response = client.Query(request);
foreach (var item in response.Items)
{
// Write out the first page of an item's attribute keys and values.
// PrintItem() is a custom function.
PrintItem(item);
Console.WriteLine("=====");
}
```
Im vorangegangenen Beispiel gibt die `ProjectionExpression`-Eigenschaft die zurückzugebenden Attribute an. Die `ExpressionAttributeNames`-Eigenschaft gibt den Platzhalter `#pr` an, der das `ProductReviews`-Attribut repräsentiert sowie den Platzhalter `#p`, der für das `Price`-Attribut steht. `#pr.ThreeStar` gibt an, dass nur das `ThreeStar`-Attribut zurückgegeben werden soll. Die `ExpressionAttributeValues`-Eigenschaft gibt den Platzhalter `:val` an, der den Wert `150` repräsentiert. Die `FilterExpression`-Eigenschaft gibt an, dass `#p` (`Price`) größer als `:val` (`150`) sein muss. Das Aufrufen von `PrintItem` bezieht sich auf eine benutzerdefinierte Funktion, wie unter [Drucken eines Elements](#dynamodb-expressions-print-item) beschrieben.
## Abrufen von mehreren Elementen mithilfe von Ausdrücken und anderen Element-Attributen
Im folgenden Beispiel werden die `Amazon.DynamoDBv2.AmazonDynamoDBClient.Scan`-Methode sowie eine Gruppe von Ausdrücken zum Abrufen und anschließenden Drucken aller Elemente mit einer `ProductCategory` von `Bike` veranschaulicht. Es werden nur die folgenden Attribute des Elements zurückgegeben: `Id`, `Title` sowie sämtliche Attribute in `ProductReviews`.
```
// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;
var client = new AmazonDynamoDBClient();
var request = new ScanRequest
{
TableName = "ProductCatalog",
ProjectionExpression = "Id, Title, #pr",
ExpressionAttributeValues = new Dictionary
{
{ ":catg", new AttributeValue { S = "Bike" } }
},
ExpressionAttributeNames = new Dictionary
{
{ "#pr", "ProductReviews" },
{ "#pc", "ProductCategory" }
},
FilterExpression = "#pc = :catg",
};
var response = client.Scan(request);
foreach (var item in response.Items)
{
// Write out the first page/scan of an item's attribute keys and values.
// PrintItem() is a custom function.
PrintItem(item);
Console.WriteLine("=====");
}
```
Im vorangegangenen Beispiel gibt die `ProjectionExpression`-Eigenschaft die zurückzugebenden Attribute an. Die `ExpressionAttributeNames`-Eigenschaft gibt den Platzhalter `#pr` an, der das `ProductReviews`-Attribut repräsentiert sowie den Platzhalter `#pc`, der für das `ProductCategory`-Attribut steht. Die `ExpressionAttributeValues`-Eigenschaft gibt den Platzhalter `:catg` an, der den Wert `Bike` repräsentiert. Die `FilterExpression`-Eigenschaft gibt an, dass `#pc` (`ProductCategory`) gleich `:catg` (`Bike`) sein muss. Das Aufrufen von `PrintItem` bezieht sich auf eine benutzerdefinierte Funktion, wie unter [Drucken eines Elements](#dynamodb-expressions-print-item) beschrieben.
## Drucken eines Elements
Im folgenden Beispiel wird gezeigt, wie die Attribute und Werte eines Elements gedruckt werden. Dieses Beispiel wird in den vorherigen Beispielen verwendet, in denen Folgendes veranschaulicht wurde: [Abrufen eines einzelnen Elements mithilfe von Ausdrücken und dem Primärschlüssel des Elements](#dynamodb-expressions-get-item), [Abrufen von mehreren Elements mithilfe von Ausdrücken und dem Primärschlüssel der Tabelle](#dynamodb-expressions-query) sowie [Abrufen von mehreren Elements mithilfe von Ausdrücken und anderen Element-Attributen](#dynamodb-expressions-scan).
```
// using Amazon.DynamoDBv2.Model;
// Writes out an item's attribute keys and values.
public static void PrintItem(Dictionary attrs)
{
foreach (KeyValuePair kvp in attrs)
{
Console.Write(kvp.Key + " = ");
PrintValue(kvp.Value);
}
}
// Writes out just an attribute's value.
public static void PrintValue(AttributeValue value)
{
// Binary attribute value.
if (value.B != null)
{
Console.Write("Binary data");
}
// Binary set attribute value.
else if (value.BS.Count > 0)
{
foreach (var bValue in value.BS)
{
Console.Write("\n Binary data");
}
}
// List attribute value.
else if (value.L.Count > 0)
{
foreach (AttributeValue attr in value.L)
{
PrintValue(attr);
}
}
// Map attribute value.
else if (value.M.Count > 0)
{
Console.Write("\n");
PrintItem(value.M);
}
// Number attribute value.
else if (value.N != null)
{
Console.Write(value.N);
}
// Number set attribute value.
else if (value.NS.Count > 0)
{
Console.Write("{0}", string.Join("\n", value.NS.ToArray()));
}
// Null attribute value.
else if (value.NULL)
{
Console.Write("Null");
}
// String attribute value.
else if (value.S != null)
{
Console.Write(value.S);
}
// String set attribute value.
else if (value.SS.Count > 0)
{
Console.Write("{0}", string.Join("\n", value.SS.ToArray()));
}
// Otherwise, boolean value.
else
{
Console.Write(value.BOOL);
}
Console.Write("\n");
}
```
Im vorherigen Beispiel hat jeder Attributwert mehrere data-type-specific Eigenschaften, die ausgewertet werden können, um das richtige Format für den Ausdruck des Attributs zu bestimmen. Zu diesen Eigenschaften gehören `B`, `BOOL`, `BS`, `L`, `M`, `N`, `NS`, `NULL`, `S` und `SS`, die jenen im [JSON-Datenformat](DataFormat.html) entsprechen. Wenn bei Eigenschaften wie `B`, `N`, `NULL` und `S` die entsprechende Eigenschaft nicht `null` ist, besitzt das Attribut den entsprechenden nicht-`null`-Datentyp. Bei Eigenschaften wie`BS`,, `L``M`, und `NS``SS`, wenn `Count` der Wert größer als Null ist, hat das Attribut den entsprechenden non-zero-value Datentyp. Wenn alle data-type-specific Eigenschaften des Attributs entweder `null` oder `Count` gleich Null sind, entspricht das Attribut dem `BOOL` Datentyp.
## Erstellen oder Ersetzen eines Elements mithilfe von Ausdrücken
Im folgenden Beispiel werden die `Amazon.DynamoDBv2.AmazonDynamoDBClient.PutItem`-Methode sowie eine Gruppe von Ausdrücken zum Aktualisieren des Elements mit einem `Title` von `18-Bicycle 301` veranschaulicht. Wenn das Element noch nicht vorhanden ist, wird ein neues Element hinzugefügt.
```
// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;
var client = new AmazonDynamoDBClient();
var request = new PutItemRequest
{
TableName = "ProductCatalog",
ExpressionAttributeNames = new Dictionary
{
{ "#title", "Title" }
},
ExpressionAttributeValues = new Dictionary
{
{ ":product", new AttributeValue { S = "18-Bicycle 301" } }
},
ConditionExpression = "#title = :product",
// CreateItemData() is a custom function.
Item = CreateItemData()
};
client.PutItem(request);
```
Im vorangegangenen Beispiel gibt die `ExpressionAttributeNames`-Eigenschaft den Platzhalter `#title` an, der das `Title`-Attribut repräsentiert. Die `ExpressionAttributeValues`-Eigenschaft gibt den Platzhalter `:product` an, der den Wert `18-Bicycle 301` repräsentiert. Die `ConditionExpression`-Eigenschaft gibt an, dass `#title` (`Title`) gleich `:product` (`18-Bicycle 301`) sein muss. Das Aufrufen von `CreateItemData` bezieht sich auf die folgende benutzerdefinierte Funktion:
```
// using Amazon.DynamoDBv2.Model;
// Provides a sample item that can be added to a table.
public static Dictionary CreateItemData()
{
var itemData = new Dictionary
{
{ "Id", new AttributeValue { N = "301" } },
{ "Title", new AttributeValue { S = "18\" Girl's Bike" } },
{ "BicycleType", new AttributeValue { S = "Road" } },
{ "Brand" , new AttributeValue { S = "Brand-Company C" } },
{ "Color", new AttributeValue { SS = new List{ "Blue", "Silver" } } },
{ "Description", new AttributeValue { S = "301 description" } },
{ "Gender", new AttributeValue { S = "F" } },
{ "InStock", new AttributeValue { BOOL = true } },
{ "Pictures", new AttributeValue { L = new List{
{ new AttributeValue { M = new Dictionary{
{ "FrontView", new AttributeValue { S = "http://example/products/301_front.jpg" } } } } },
{ new AttributeValue { M = new Dictionary{
{ "RearView", new AttributeValue {S = "http://example/products/301_rear.jpg" } } } } },
{ new AttributeValue { M = new Dictionary{
{ "SideView", new AttributeValue { S = "http://example/products/301_left_side.jpg" } } } } }
} } },
{ "Price", new AttributeValue { N = "185" } },
{ "ProductCategory", new AttributeValue { S = "Bike" } },
{ "ProductReviews", new AttributeValue { M = new Dictionary{
{ "FiveStar", new AttributeValue { SS = new List{
"My daughter really enjoyed this bike!" } } },
{ "OneStar", new AttributeValue { SS = new List{
"Fun to ride.",
"This bike was okay, but I would have preferred it in my color." } } }
} } },
{ "QuantityOnHand", new AttributeValue { N = "3" } },
{ "RelatedItems", new AttributeValue { NS = new List{ "979", "822", "801" } } }
};
return itemData;
}
```
Im vorherigen Beispiel wird ein Beispielelement mit Beispieldaten an den Aufrufer zurückgegeben. Es werden eine Reihe von Attributen und entsprechenden Werten erstellt, indem Datentypen wie `BOOL`, `L`, `M`, `N`, `NS`, `S` und `SS` verwendet werden, die jenen im [JSON-Datenformat](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataFormat.html) entsprechen.
## Aktualisieren eines Elements mithilfe von Ausdrücken
Im folgenden Beispiel werden die `Amazon.DynamoDBv2.AmazonDynamoDBClient.UpdateItem`-Methode sowie eine Gruppe von Ausdrücken zum Ändern von `Title` in `18" Girl's Bike` für das Element mit einer `Id` von `301` veranschaulicht.
```
// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;
var client = new AmazonDynamoDBClient();
var request = new UpdateItemRequest
{
TableName = "ProductCatalog",
Key = new Dictionary
{
{ "Id", new AttributeValue { N = "301" } }
},
ExpressionAttributeNames = new Dictionary
{
{ "#title", "Title" }
},
ExpressionAttributeValues = new Dictionary
{
{ ":newproduct", new AttributeValue { S = "18\" Girl's Bike" } }
},
UpdateExpression = "SET #title = :newproduct"
};
client.UpdateItem(request);
```
Im vorangegangenen Beispiel gibt die `ExpressionAttributeNames`-Eigenschaft den Platzhalter `#title` an, der das `Title`-Attribut repräsentiert. Die `ExpressionAttributeValues`-Eigenschaft gibt den Platzhalter `:newproduct` an, der den Wert `18" Girl's Bike` repräsentiert. Die `UpdateExpression`-Eigenschaft gibt an, dass `#title` (`Title`) in `:newproduct` (`18" Girl's Bike`) geändert werden soll.
## Löschen eines Elements mithilfe von Ausdrücken
Im folgenden Beispiel werden die `Amazon.DynamoDBv2.AmazonDynamoDBClient.DeleteItem`-Methode sowie eine Gruppe von Ausdrücken zum Löschen eines Elements mit einer `Id` von `301` veranschaulicht, allerdings nur, wenn der `Title` des Elements `18-Bicycle 301` lautet.
```
// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;
var client = new AmazonDynamoDBClient();
var request = new DeleteItemRequest
{
TableName = "ProductCatalog",
Key = new Dictionary
{
{ "Id", new AttributeValue { N = "301" } }
},
ExpressionAttributeNames = new Dictionary
{
{ "#title", "Title" }
},
ExpressionAttributeValues = new Dictionary
{
{ ":product", new AttributeValue { S = "18-Bicycle 301" } }
},
ConditionExpression = "#title = :product"
};
client.DeleteItem(request);
```
Im vorangegangenen Beispiel gibt die `ExpressionAttributeNames`-Eigenschaft den Platzhalter `#title` an, der das `Title`-Attribut repräsentiert. Die `ExpressionAttributeValues`-Eigenschaft gibt den Platzhalter `:product` an, der den Wert `18-Bicycle 301` repräsentiert. Die `ConditionExpression`-Eigenschaft gibt an, dass `#title` (`Title`) gleich `:product` (`18-Bicycle 301`) sein muss.
## Weitere Infos
Weitere Informationen und Codeeispiele finden Sie unter
+ [DynamoDB Series - Expressions](http://blogs.aws.amazon.com/net/post/TxZQM7VA9AUZ9L/DynamoDB-Series-Expressions)
+ [Angeben von Elementattributen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html)
+ [Ausdrucksattributnamen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ExpressionPlaceholders.html)
+ [Bedingungsausdrücke](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html)
+ [Aktualisierungsausdrücke](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.Modifying.html)
+ [Arbeiten mit Elementen mithilfe der AWS SDK für .NET Low-Level-API](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetItemCRUD.html)
+ [Abfragen von Tabellen mithilfe der Low-Level-API AWS SDK für .NET](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetQuerying.html)
+ [Scannen von Tabellen mithilfe der AWS SDK für .NET Low-Level-API](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetScanning.html)
+ [Arbeiten mit lokalen Sekundärindizes mithilfe der AWS SDK für .NET Low-Level-API](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LSILowLevelDotNet.html)
+ [Arbeiten mit globalen Sekundärindizes mithilfe der Low-Level-API AWS SDK für .NET](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSILowLevelDotNet.html)
# JSON-Unterstützung in Amazon DynamoDB
**Anmerkung**
Die Informationen in diesem Thema beziehen sich speziell auf Projekte, die auf .NET Framework und AWS SDK für .NET Version 3.3 und früher basieren.
Das AWS SDK für .NET unterstützt JSON-Daten bei der Arbeit mit Amazon DynamoDB. Auf diese Weise können Sie einfacher JSON-formatierte Daten aus DynamoDB-Tabellen abrufen und JSON-Dokumente in DynamoDB-Tabellen einfügen.
**Topics**
+ [Daten aus einer DynamoDB-Tabelle im JSON-Format abrufen](#dynamodb-json-get-table-data)
+ [Daten im JSON-Format in eine DynamoDB-Tabelle einfügen](#dynamodb-json-insert-table-data)
+ [DynamoDB-Datentypkonvertierungen nach JSON](#dynamodb-json-datatypes)
+ [Weitere Infos](#dynamodb-json-more-info)
## Daten aus einer DynamoDB-Tabelle im JSON-Format abrufen
Das folgende Beispiel zeigt, wie Daten aus einer DynamoDB-Tabelle im JSON-Format abgerufen werden:
```
// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.DocumentModel;
var client = new AmazonDynamoDBClient();
var table = Table.LoadTable(client, "AnimalsInventory");
var item = table.GetItem(3, "Horse");
var jsonText = item.ToJson();
Console.Write(jsonText);
// Output:
// {"Name":"Shadow","Type":"Horse","Id":3}
var jsonPrettyText = item.ToJsonPretty();
Console.WriteLine(jsonPrettyText);
// Output:
// {
// "Name" : "Shadow",
// "Type" : "Horse",
// "Id" : 3
// }
```
Im vorherigen Beispiel wird ein Element aus der Tabelle mithilfe der `ToJson`-Methode der `Document`-Klasse in eine Zeichenfolge im JSON-Format konvertiert. Das Element wird durch die `GetItem`-Methode der `Table`-Klasse abgerufen. Um das abzurufende Element zu bestimmen, verwendet die `GetItem` Methode in diesem Beispiel den hash-and-range Primärschlüssel des Zielelements. Um die Tabelle zu ermitteln, aus der das Element abgerufen werden soll, verwendet die `LoadTable` Methode der `Table` Klasse eine Instanz der `AmazonDynamoDBClient` Klasse und den Namen der Zieltabelle in DynamoDB.
## Daten im JSON-Format in eine DynamoDB-Tabelle einfügen
Das folgende Beispiel zeigt, wie das JSON-Format verwendet wird, um ein Element in eine DynamoDB-Tabelle einzufügen:
```
// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.DocumentModel;
var client = new AmazonDynamoDBClient();
var table = Table.LoadTable(client, "AnimalsInventory");
var jsonText = "{\"Id\":6,\"Type\":\"Bird\",\"Name\":\"Tweety\"}";
var item = Document.FromJson(jsonText);
table.PutItem(item);
```
Im vorherigen Beispiel wird eine Zeichenfolge im JSON-Format mithilfe der `FromJson`-Methode der `Document`-Klasse in ein Element konvertiert. Das Einfügen des Elements in die Tabelle erfolgt mithilfe der `PutItem`-Methode der `Table`-Klasse, die eine Instance der `Document`-Klasse verwendet, die das Element enthält. Um die Tabelle zu bestimmen, in die das Element eingefügt werden soll, wird die `LoadTable` Methode der `Table` Klasse aufgerufen, wobei eine Instanz der `AmazonDynamoDBClient` Klasse und der Name der Zieltabelle in DynamoDB angegeben werden.
## DynamoDB-Datentypkonvertierungen nach JSON
Immer wenn Sie die `ToJson` Methode der `Document` Klasse aufrufen und dann für die resultierenden JSON-Daten die `FromJson` Methode aufrufen, um die JSON-Daten wieder in eine Instanz einer `Document` Klasse zu konvertieren, werden einige DynamoDB-Datentypen nicht wie erwartet konvertiert. Das heißt:
+ DynamoDB-Sets (die `BS` Typen `SS``NS`, und) werden in JSON-Arrays konvertiert.
+ DynamoDB-Binärskalare und -mengen (die `BS` Typen `B` und) werden in Base64-kodierte JSON-Zeichenfolgen oder Zeichenkettenlisten konvertiert.
In diesem Szenario müssen Sie die `DecodeBase64Attributes`-Methode der `Document`-Klasse aufrufen, um die base64-verschlüsselten JSON-Daten durch die korrekte binäre Darstellung zu ersetzen. Im folgenden Beispiel wird ein base64-verschlüsseltes binärskalares Elementattribut in eine Instance einer `Document`-Klasse namens `Picture` durch die korrekte binäre Darstellung ersetzt. In diesem Beispiel wird dasselbe auch für ein base64-verschlüsseltes Binärsatzelementattribut in derselben Instance der `Document`-Klasse namens `RelatedPictures` ausgeführt:
```
item.DecodeBase64Attributes("Picture", "RelatedPictures");
```
## Weitere Infos
Weitere Informationen und Beispiele für die Programmierung von JSON mit DynamoDB mit dem finden Sie unter AWS SDK für .NET:
+ [JSON-Unterstützung in DynamoDB](https://aws.amazon.com/blogs/developer/dynamodb-json-support/)
+ [Amazon DynamoDB-Aktualisierungen - JSON, Erweitertes kostenloses Kontingent, Flexible Skalierung, Größere Elemente](https://aws.amazon.com/blogs/aws/dynamodb-update-json-and-more/)
# Arbeiten mit Amazon EC2
Der AWS SDK für .NET unterstützt [Amazon EC2](https://docs.aws.amazon.com/ec2/), einen Webservice, der skalierbare Rechenkapazität bietet. Sie verwenden diese Rechenkapazität, um Ihre Softwaresysteme zu erstellen und zu hosten.
## APIs
Das AWS SDK für .NET stellt APIs für Amazon EC2 EC2-Clients bereit. Die APIs ermöglichen es Ihnen, mit EC2-Funktionen wie Sicherheitsgruppen und Schlüsselpaaren zu arbeiten. Die APIs ermöglichen Ihnen auch die Steuerung von Amazon EC2 EC2-Instances. Dieser Abschnitt enthält eine kleine Anzahl von Beispielen, die Ihnen zeigen, welchen Mustern Sie bei der Arbeit mit diesen APIs Modellen folgen können. Den vollständigen Satz von finden Sie in der APIs [AWS SDK für .NET API-Referenz](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/) (und scrollen Sie zu „Amazon.ec2").
Die Amazon EC2 APIs werden durch das [AWSSDK NuGet .EC2-Paket](https://www.nuget.org/packages/AWSSDK.EC2) bereitgestellt.
## Voraussetzungen
Bevor Sie beginnen, stellen Sie sicher, dass Sie [Ihre Umgebung und Ihr Projekt eingerichtet](net-dg-config.md) haben. Lesen Sie auch die Informationen unter[SDK-Funktionen](net-dg-sdk-features.md).
## Informationen zu den Beispielen
Die Beispiele in diesem Abschnitt zeigen Ihnen, wie Sie mit Amazon EC2 EC2-Clients arbeiten und Amazon EC2 EC2-Instances verwalten.
Das [EC2-Spot-Instance-Tutorial](how-to-spot-instances.md) zeigt Ihnen, wie Sie Amazon EC2-Spot-Instances anfordern. Spot-Instances ermöglichen Ihnen den Zugriff auf ungenutzte EC2-Kapazität für weniger als den On-Demand-Preis.
**Topics**
+ [APIs](#w2aac19c15c17b5)
+ [Voraussetzungen](#w2aac19c15c17b7)
+ [Informationen zu den Beispielen](#ec2-apis-intro-about)
+ [Sicherheitsgruppen](security-groups.md)
+ [Schlüsselpaare](key-pairs.md)
+ [Regionen und Availability Zones](using-regions-and-availability-zones.md)
+ [EC2-Instanzen](how-to-ec2.md)
+ [Anleitung zur Spot-Instance](how-to-spot-instances.md)
# Arbeiten mit Sicherheitsgruppen in Amazon EC2
In Amazon EC2 fungiert eine *Sicherheitsgruppe* als virtuelle Firewall, die den Netzwerkverkehr für eine oder mehrere EC2-Instances steuert. Standardmäßig ordnet EC2 Ihre Instances einer Sicherheitsgruppe zu, die keinen eingehenden Datenverkehr zulässt. Sie können eine Sicherheitsgruppe erstellen, die es den EC2-Instances ermöglicht, eingehenden Datenverkehr zu akzeptieren. Wenn Sie beispielsweise eine Verbindung zu einer EC2 Windows-Instance herstellen müssen, muss die Sicherheitsgruppe so konfiguriert werden, dass RDP-Datenverkehr möglich ist.
Weitere Informationen zu Sicherheitsgruppen finden Sie unter [Amazon EC2-Sicherheitsgruppen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html) im [Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
**Warnung**
EC2-Classic wurde am 15. August 2022 außer Betrieb genommen. Wir empfehlen Ihnen die Migration von EC2-Classic zu einer VPC. Weitere Informationen finden Sie im Blogbeitrag [EC2-Classic Networking is Retiring — So](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/) bereiten Sie sich vor.
Informationen zu den Voraussetzungen APIs und Voraussetzungen finden Sie im übergeordneten Abschnitt (). [Arbeiten mit Amazon EC2](ec2-apis-intro.md)
**Topics**
+ [Auflisten von Sicherheitsgruppen](enumerate-security-groups.md)
+ [Erstellen von Sicherheitsgruppen](creating-security-group.md)
+ [Sicherheitsgruppen werden aktualisiert](authorize-ingress.md)
# Auflisten von Sicherheitsgruppen
Dieses Beispiel zeigt Ihnen, wie Sie die verwenden, AWS SDK für .NET um Sicherheitsgruppen aufzulisten. Wenn Sie eine [Amazon Virtual Private Cloud Cloud-ID angeben](https://docs.aws.amazon.com/vpc/latest/userguide/), listet die Anwendung die Sicherheitsgruppen für diese bestimmte VPC auf. Andernfalls zeigt die Anwendung einfach eine Liste aller verfügbaren Sicherheitsgruppen an.
Die folgenden Abschnitte enthalten Auszüge aus diesem Beispiel. Der [vollständige Code für das Beispiel](#enum-sec-groups-complete-code) wird danach angezeigt und kann unverändert erstellt und ausgeführt werden.
**Topics**
+ [Zählen Sie Sicherheitsgruppen auf](#enum-sec-groups-enum)
+ [Vollständiger Code](#enum-sec-groups-complete-code)
+ [Weitere Überlegungen](#enum-sec-groups-additional)
## Zählen Sie Sicherheitsgruppen auf
Der folgende Ausschnitt listet Ihre Sicherheitsgruppen auf. Es listet alle Gruppen oder die Gruppen für eine bestimmte VPC auf, falls eine angegeben ist.
Das Beispiel [am Ende dieses Themas zeigt, wie dieser](#enum-sec-groups-complete-code) Codeausschnitt verwendet wird.
```
//
// Method to enumerate the security groups
private static async Task EnumerateGroups(IAmazonEC2 ec2Client, string vpcID)
{
// A request object, in case we need it.
var request = new DescribeSecurityGroupsRequest();
// Put together the properties, if needed
if(!string.IsNullOrEmpty(vpcID))
{
// We have a VPC ID. Find the security groups for just that VPC.
Console.WriteLine($"\nGetting security groups for VPC {vpcID}...\n");
request.Filters.Add(new Filter
{
Name = "vpc-id",
Values = new List() { vpcID }
});
}
// Get the list of security groups
DescribeSecurityGroupsResponse response =
await ec2Client.DescribeSecurityGroupsAsync(request);
// Display the list of security groups.
foreach (SecurityGroup item in response.SecurityGroups)
{
Console.WriteLine("Security group: " + item.GroupId);
Console.WriteLine("\tGroupId: " + item.GroupId);
Console.WriteLine("\tGroupName: " + item.GroupName);
Console.WriteLine("\tVpcId: " + item.VpcId);
Console.WriteLine();
}
}
```
## Vollständiger Code
Dieser Abschnitt enthält relevante Referenzen und den vollständigen Code für dieses Beispiel.
### SDK-Referenzen
NuGet Pakete:
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Elemente der Programmierung:
+ [Namespace Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2.html)
Klasse [EC2Amazon-Kunde](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
+ [Namespace Amazon.EC2.Model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Klasse [DescribeSecurityGroupsRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeSecurityGroupsRequest.html)
Klasse [DescribeSecurityGroupsResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeSecurityGroupsResponse.html)
[Klassenfilter](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TFilter.html)
Klasse [SecurityGroup](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TSecurityGroup.html)
### Der Kodex
```
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using Amazon.EC2;
using Amazon.EC2.Model;
namespace EC2EnumerateSecGroups
{
class Program
{
static async Task Main(string[] args)
{
// Parse the command line
string vpcID = string.Empty;
if(args.Length == 0)
{
Console.WriteLine("\nEC2EnumerateSecGroups [vpc_id]");
Console.WriteLine(" vpc_id - The ID of the VPC for which you want to see security groups.");
Console.WriteLine("\nSince you specified no arguments, showing all available security groups.");
}
else
{
vpcID = args[0];
}
if(vpcID.StartsWith("vpc-") || string.IsNullOrEmpty(vpcID))
{
// Create an EC2 client object
var ec2Client = new AmazonEC2Client();
// Enumerate the security groups
await EnumerateGroups(ec2Client, vpcID);
}
else
{
Console.WriteLine("Could not find a valid VPC ID in the command-line arguments:");
Console.WriteLine($"{args[0]}");
}
}
//
// Method to enumerate the security groups
private static async Task EnumerateGroups(IAmazonEC2 ec2Client, string vpcID)
{
// A request object, in case we need it.
var request = new DescribeSecurityGroupsRequest();
// Put together the properties, if needed
if(!string.IsNullOrEmpty(vpcID))
{
// We have a VPC ID. Find the security groups for just that VPC.
Console.WriteLine($"\nGetting security groups for VPC {vpcID}...\n");
request.Filters.Add(new Filter
{
Name = "vpc-id",
Values = new List() { vpcID }
});
}
// Get the list of security groups
DescribeSecurityGroupsResponse response =
await ec2Client.DescribeSecurityGroupsAsync(request);
// Display the list of security groups.
foreach (SecurityGroup item in response.SecurityGroups)
{
Console.WriteLine("Security group: " + item.GroupId);
Console.WriteLine("\tGroupId: " + item.GroupId);
Console.WriteLine("\tGroupName: " + item.GroupName);
Console.WriteLine("\tVpcId: " + item.VpcId);
Console.WriteLine();
}
}
}
}
```
## Weitere Überlegungen
+ Beachten Sie für den VPC-Fall, dass der Filter so konstruiert ist, dass der `Name` Teil des Name-Wert-Paares auf „vpc-id“ gesetzt ist. Dieser Name stammt aus der Beschreibung der Eigenschaft der `Filters` Klasse. [DescribeSecurityGroupsRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeSecurityGroupsRequest.html)
+ Um die vollständige Liste Ihrer Sicherheitsgruppen zu erhalten, können Sie diese auch [ DescribeSecurityGroupsAsync ohne Parameter](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/MEC2DescribeSecurityGroupsAsyncCancellationToken.html) verwenden.
+ Sie können die Ergebnisse überprüfen, indem Sie die Liste der Sicherheitsgruppen in der [Amazon EC2 EC2-Konsole](https://console.aws.amazon.com/ec2/v2/home#SecurityGroups) überprüfen.
# Erstellen von Sicherheitsgruppen
Dieses Beispiel zeigt Ihnen, wie Sie mit AWS SDK für .NET dem eine Sicherheitsgruppe erstellen. Sie können die ID einer vorhandenen VPC angeben, um eine Sicherheitsgruppe für EC2 in einer VPC zu erstellen. Wenn Sie keine solche ID angeben, gilt die neue Sicherheitsgruppe für EC2-Classic, sofern Ihr Konto dies unterstützt. AWS
Wenn Sie keine VPC-ID angeben und Ihr AWS Konto EC2-Classic nicht unterstützt, gehört die neue Sicherheitsgruppe zur Standard-VPC Ihres Kontos.
**Warnung**
EC2-Classic wurde am 15. August 2022 außer Betrieb genommen. Wir empfehlen Ihnen die Migration von EC2-Classic zu einer VPC. Weitere Informationen finden Sie im Blogbeitrag [EC2-Classic Networking is Retiring](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/) — So bereiten Sie sich vor.
Die folgenden Abschnitte enthalten Auszüge aus diesem Beispiel. Der [vollständige Code für das Beispiel](#create-sec-groups-complete-code) wird danach angezeigt und kann unverändert erstellt und ausgeführt werden.
**Topics**
+ [Suchen Sie nach vorhandenen Sicherheitsgruppen](#create-sec-groups-find)
+ [Eine Sicherheitsgruppe erstellen](#create-sec-groups-enum)
+ [Vollständiger Code](#create-sec-groups-complete-code)
## Suchen Sie nach vorhandenen Sicherheitsgruppen
Das folgende Snippet sucht nach vorhandenen Sicherheitsgruppen mit dem angegebenen Namen in der angegebenen VPC.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#create-sec-groups-complete-code) Snippet verwendet wird.
```
//
// Method to determine if a security group with the specified name
// already exists in the VPC
private static async Task> FindSecurityGroups(
IAmazonEC2 ec2Client, string groupName, string vpcID)
{
var request = new DescribeSecurityGroupsRequest();
request.Filters.Add(new Filter{
Name = "group-name",
Values = new List() { groupName }
});
if(!string.IsNullOrEmpty(vpcID))
request.Filters.Add(new Filter{
Name = "vpc-id",
Values = new List() { vpcID }
});
var response = await ec2Client.DescribeSecurityGroupsAsync(request);
return response.SecurityGroups;
}
```
## Eine Sicherheitsgruppe erstellen
Das folgende Snippet erstellt eine neue Sicherheitsgruppe, wenn eine Gruppe mit diesem Namen in der angegebenen VPC nicht existiert. Wenn keine VPC angegeben ist und eine oder mehrere Gruppen mit diesem Namen existieren, gibt das Snippet einfach die Liste der Gruppen zurück.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#create-sec-groups-complete-code) Snippet verwendet wird.
```
//
// Method to create a new security group (either EC2-Classic or EC2-VPC)
// If vpcID is empty, the security group will be for EC2-Classic
private static async Task> CreateSecurityGroup(
IAmazonEC2 ec2Client, string groupName, string vpcID)
{
// See if one or more security groups with that name
// already exist in the given VPC. If so, return the list of them.
var securityGroups = await FindSecurityGroups(ec2Client, groupName, vpcID);
if (securityGroups.Count > 0)
{
Console.WriteLine(
$"\nOne or more security groups with name {groupName} already exist.\n");
return securityGroups;
}
// If the security group doesn't already exists, create it.
var createRequest = new CreateSecurityGroupRequest{
GroupName = groupName
};
if(string.IsNullOrEmpty(vpcID))
{
createRequest.Description = "My .NET example security group for EC2-Classic";
}
else
{
createRequest.VpcId = vpcID;
createRequest.Description = "My .NET example security group for EC2-VPC";
}
CreateSecurityGroupResponse createResponse =
await ec2Client.CreateSecurityGroupAsync(createRequest);
// Return the new security group
DescribeSecurityGroupsResponse describeResponse =
await ec2Client.DescribeSecurityGroupsAsync(new DescribeSecurityGroupsRequest{
GroupIds = new List() { createResponse.GroupId }
});
return describeResponse.SecurityGroups;
}
```
## Vollständiger Code
Dieser Abschnitt enthält relevante Referenzen und den vollständigen Code für dieses Beispiel.
### SDK-Referenzen
NuGet Pakete:
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Elemente der Programmierung:
+ [Namespace Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2.html)
Klasse [EC2Amazon-Kunde](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
+ [Namespace Amazon.EC2.Model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Klasse [CreateSecurityGroupRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TCreateSecurityGroupRequest.html)
Klasse [CreateSecurityGroupResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TCreateSecurityGroupResponse.html)
Klasse [DescribeSecurityGroupsRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeSecurityGroupsRequest.html)
Klasse [DescribeSecurityGroupsResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeSecurityGroupsResponse.html)
[Klassenfilter](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TFilter.html)
Klasse [SecurityGroup](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TSecurityGroup.html)
### Der Code
```
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using Amazon.EC2;
using Amazon.EC2.Model;
namespace EC2CreateSecGroup
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to create a security group
class Program
{
private const int MaxArgs = 2;
static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if(parsedArgs.Count == 0)
{
PrintHelp();
return;
}
if(parsedArgs.Count > MaxArgs)
CommandLine.ErrorExit("\nThe number of command-line arguments is incorrect." +
"\nRun the command with no arguments to see help.");
// Get the application arguments from the parsed list
var groupName = CommandLine.GetArgument(parsedArgs, null, "-g", "--group-name");
var vpcID = CommandLine.GetArgument(parsedArgs, null, "-v", "--vpc-id");
if(string.IsNullOrEmpty(groupName))
CommandLine.ErrorExit("\nYou must supply a name for the new group." +
"\nRun the command with no arguments to see help.");
if(!string.IsNullOrEmpty(vpcID) && !vpcID.StartsWith("vpc-"))
CommandLine.ErrorExit($"\nNot a valid VPC ID: {vpcID}");
// groupName has a value and vpcID either has a value or is null (which is fine)
// Create the new security group and display information about it
var securityGroups =
await CreateSecurityGroup(new AmazonEC2Client(), groupName, vpcID);
Console.WriteLine("Information about the security group(s):");
foreach(var group in securityGroups)
{
Console.WriteLine($"\nGroupName: {group.GroupName}");
Console.WriteLine($"GroupId: {group.GroupId}");
Console.WriteLine($"Description: {group.Description}");
Console.WriteLine($"VpcId (if any): {group.VpcId}");
}
}
//
// Method to create a new security group (either EC2-Classic or EC2-VPC)
// If vpcID is empty, the security group will be for EC2-Classic
private static async Task> CreateSecurityGroup(
IAmazonEC2 ec2Client, string groupName, string vpcID)
{
// See if one or more security groups with that name
// already exist in the given VPC. If so, return the list of them.
var securityGroups = await FindSecurityGroups(ec2Client, groupName, vpcID);
if (securityGroups.Count > 0)
{
Console.WriteLine(
$"\nOne or more security groups with name {groupName} already exist.\n");
return securityGroups;
}
// If the security group doesn't already exists, create it.
var createRequest = new CreateSecurityGroupRequest{
GroupName = groupName
};
if(string.IsNullOrEmpty(vpcID))
{
createRequest.Description = "Security group for .NET code example (no VPC specified)";
}
else
{
createRequest.VpcId = vpcID;
createRequest.Description = "Security group for .NET code example (VPC: " + vpcID + ")";
}
CreateSecurityGroupResponse createResponse =
await ec2Client.CreateSecurityGroupAsync(createRequest);
// Return the new security group
DescribeSecurityGroupsResponse describeResponse =
await ec2Client.DescribeSecurityGroupsAsync(new DescribeSecurityGroupsRequest{
GroupIds = new List() { createResponse.GroupId }
});
return describeResponse.SecurityGroups;
}
//
// Method to determine if a security group with the specified name
// already exists in the VPC
private static async Task> FindSecurityGroups(
IAmazonEC2 ec2Client, string groupName, string vpcID)
{
var request = new DescribeSecurityGroupsRequest();
request.Filters.Add(new Filter{
Name = "group-name",
Values = new List() { groupName }
});
if(!string.IsNullOrEmpty(vpcID))
request.Filters.Add(new Filter{
Name = "vpc-id",
Values = new List() { vpcID }
});
var response = await ec2Client.DescribeSecurityGroupsAsync(request);
return response.SecurityGroups;
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine(
"\nUsage: EC2CreateSecGroup -g [-v ]" +
"\n -g, --group-name: The name you would like the new security group to have." +
"\n -v, --vpc-id: The ID of a VPC to which the new security group will belong." +
"\n If vpc-id isn't present, the security group will be" +
"\n for EC2-Classic (if your AWS account supports this)" +
"\n or will use the default VCP for EC2-VPC.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
# Sicherheitsgruppen werden aktualisiert
Dieses Beispiel zeigt Ihnen, wie Sie AWS SDK für .NET mit dem einer Sicherheitsgruppe eine Regel hinzufügen können. Insbesondere fügt das Beispiel eine Regel hinzu, die eingehenden Datenverkehr an einem bestimmten TCP-Port zulässt, was beispielsweise für Remoteverbindungen zu einer EC2-Instance verwendet werden kann. Die Anwendung verwendet die ID einer vorhandenen Sicherheitsgruppe, eine IP-Adresse (oder einen Adressbereich) im CIDR-Format und optional eine TCP-Portnummer. Anschließend fügt sie der angegebenen Sicherheitsgruppe eine Regel für eingehenden Datenverkehr hinzu.
**Anmerkung**
Um dieses Beispiel verwenden zu können, benötigen Sie eine IP-Adresse (oder einen Adressbereich) im CIDR-Format. Methoden zum Abrufen der IP-Adresse Ihres lokalen Computers finden Sie unter **Zusätzliche Überlegungen** am Ende dieses Themas.
Die folgenden Abschnitte enthalten Auszüge aus diesem Beispiel. Der [vollständige Code für das Beispiel](#authorize-ingress-complete-code) wird danach angezeigt und kann unverändert erstellt und ausgeführt werden.
**Topics**
+ [Fügen Sie eine Regel für eingehenden Datenverkehr hinzu](#authorize-ingress-add-rule)
+ [Vollständiger Code](#authorize-ingress-complete-code)
+ [Weitere Überlegungen](#authorize-ingress-additional)
## Fügen Sie eine Regel für eingehenden Datenverkehr hinzu
Das folgende Snippet fügt einer Sicherheitsgruppe eine Regel für eingehenden Datenverkehr für eine bestimmte IP-Adresse (oder einen bestimmten Bereich) und einen bestimmten TCP-Port hinzu.
Das Beispiel [am Ende dieses Themas zeigt, wie dieser](#authorize-ingress-complete-code) Codeausschnitt verwendet wird.
```
//
// Method that adds a TCP ingress rule to a security group
private static async Task AddIngressRule(
IAmazonEC2 eC2Client, string groupID, string ipAddress, int port)
{
// Create an object to hold the request information for the rule.
// It uses an IpPermission object to hold the IP information for the rule.
var ingressRequest = new AuthorizeSecurityGroupIngressRequest{
GroupId = groupID};
ingressRequest.IpPermissions.Add(new IpPermission{
IpProtocol = "tcp",
FromPort = port,
ToPort = port,
Ipv4Ranges = new List() { new IpRange { CidrIp = ipAddress } }
});
// Create the inbound rule for the security group
AuthorizeSecurityGroupIngressResponse responseIngress =
await eC2Client.AuthorizeSecurityGroupIngressAsync(ingressRequest);
Console.WriteLine($"\nNew RDP rule was written in {groupID} for {ipAddress}.");
Console.WriteLine($"Result: {responseIngress.HttpStatusCode}");
}
```
## Vollständiger Code
Dieser Abschnitt enthält relevante Referenzen und den vollständigen Code für dieses Beispiel.
### SDK-Referenzen
NuGet Pakete:
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Elemente der Programmierung:
+ [Namespace Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2.html)
Klasse [EC2Amazon-Kunde](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
+ [Namespace Amazon.EC2.Model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Klasse [AuthorizeSecurityGroupIngressRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TAuthorizeSecurityGroupIngressRequest.html)
Klasse [AuthorizeSecurityGroupIngressResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TAuthorizeSecurityGroupIngressResponse.html)
Klasse [IpPermission](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TIpPermission.html)
Klasse [IpRange](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TIpRange.html)
### Der Code
```
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using Amazon.EC2;
using Amazon.EC2.Model;
namespace EC2AddRuleForRDP
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to add a rule that allows inbound traffic on TCP a port
class Program
{
private const int DefaultPort = 3389;
static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if(parsedArgs.Count == 0)
{
PrintHelp();
return;
}
// Get the application arguments from the parsed list
var groupID = CommandLine.GetArgument(parsedArgs, null, "-g", "--group-id");
var ipAddress = CommandLine.GetArgument(parsedArgs, null, "-i", "--ip-address");
var portStr = CommandLine.GetArgument(parsedArgs, DefaultPort.ToString(), "-p", "--port");
if(string.IsNullOrEmpty(ipAddress))
CommandLine.ErrorExit("\nYou must supply an IP address in CIDR format.");
if(string.IsNullOrEmpty(groupID) || !groupID.StartsWith("sg-"))
CommandLine.ErrorExit("\nThe ID for a security group is missing or incorrect.");
if(int.Parse(portStr) == 0)
CommandLine.ErrorExit($"\nThe given TCP port number, {portStr}, isn't allowed.");
// Add a rule to the given security group that allows
// inbound traffic on a TCP port
await AddIngressRule(
new AmazonEC2Client(), groupID, ipAddress, int.Parse(portStr));
}
//
// Method that adds a TCP ingress rule to a security group
private static async Task AddIngressRule(
IAmazonEC2 eC2Client, string groupID, string ipAddress, int port)
{
// Create an object to hold the request information for the rule.
// It uses an IpPermission object to hold the IP information for the rule.
var ingressRequest = new AuthorizeSecurityGroupIngressRequest{
GroupId = groupID};
ingressRequest.IpPermissions.Add(new IpPermission{
IpProtocol = "tcp",
FromPort = port,
ToPort = port,
Ipv4Ranges = new List() { new IpRange { CidrIp = ipAddress } }
});
// Create the inbound rule for the security group
AuthorizeSecurityGroupIngressResponse responseIngress =
await eC2Client.AuthorizeSecurityGroupIngressAsync(ingressRequest);
Console.WriteLine($"\nNew RDP rule was written in {groupID} for {ipAddress}.");
Console.WriteLine($"Result: {responseIngress.HttpStatusCode}");
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine(
"\nUsage: EC2AddRuleForRDP -g -i [-p ]" +
"\n -g, --group-id: The ID of the security group to which you want to add the inbound rule." +
"\n -i, --ip-address: An IP address or address range in CIDR format." +
"\n -p, --port: The TCP port number. Defaults to 3389.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
## Weitere Überlegungen
+ Wenn Sie keine Portnummer angeben, verwendet die Anwendung standardmäßig Port 3389. Dies ist der Port für Windows RDP, über den Sie eine Verbindung zu einer EC2-Instance herstellen können, auf der Windows ausgeführt wird. Wenn Sie eine EC2-Instance starten, auf der Linux ausgeführt wird, können Sie stattdessen TCP-Port 22 (SSH) verwenden.
+ Beachten Sie, dass das Beispiel `IpProtocol` auf „tcp“ gesetzt ist. Die Werte für `IpProtocol` finden Sie in der Beschreibung der `IpProtocol` Eigenschaft der [IpPermission](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TIpPermission.html)Klasse.
+ Wenn Sie dieses Beispiel verwenden, benötigen Sie möglicherweise die IP-Adresse Ihres lokalen Computers. Im Folgenden sind einige Möglichkeiten aufgeführt, wie Sie die Adresse abrufen können.
+ Wenn Ihr lokaler Computer (von dem aus Sie eine Verbindung zu Ihrer EC2-Instance herstellen) über eine statische öffentliche IP-Adresse verfügt, können Sie einen Dienst verwenden, um diese Adresse abzurufen. Ein solcher Dienst ist [http://checkip.amazonaws.com/](http://checkip.amazonaws.com/). Weitere Informationen zur Autorisierung von eingehendem Datenverkehr finden [Sie unter Hinzufügen von Regeln zu einer Sicherheitsgruppe](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#adding-security-group-rule) und [Sicherheitsgruppenregeln für verschiedene Anwendungsfälle](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html) im [Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
+ Eine andere Möglichkeit, die IP-Adresse Ihres lokalen Computers zu erhalten, ist die Verwendung der [Amazon EC2 EC2-Konsole](https://console.aws.amazon.com/ec2/v2/home#SecurityGroups).
Wählen Sie eine Ihrer Sicherheitsgruppen aus, klicken Sie auf die Registerkarte **Regeln für eingehenden Datenverkehr und dann auf Regeln für eingehenden** **Datenverkehr bearbeiten**. Öffnen Sie in einer Regel für eingehenden Datenverkehr das Dropdownmenü in der Spalte **Quelle** und wählen Sie **Meine IP** aus, um die IP-Adresse Ihres lokalen Computers im CIDR-Format anzuzeigen. Achten Sie darauf, den **Vorgang abzubrechen**.
+ Sie können die Ergebnisse dieses Beispiels überprüfen, indem Sie die Liste der Sicherheitsgruppen in der [Amazon EC2 EC2-Konsole](https://console.aws.amazon.com/ec2/v2/home#SecurityGroups) überprüfen.
# Arbeiten mit Amazon EC2 EC2-Schlüsselpaaren
Amazon EC2 verwendet Kryptografie für öffentliche Schlüssel, um Anmeldeinformationen zu ver- und entschlüsseln. Bei der Kryptografie mit öffentlichen Schlüsseln werden Daten mit einem öffentlichen Schlüssel verschlüsselt, und der Empfänger verwendet dann den privaten Schlüssel, um die Daten zu entschlüsseln. Der öffentliche und der private Schlüssel werden als Schlüsselpaar bezeichnet. Wenn Sie sich bei einer EC2-Instance anmelden möchten, müssen Sie beim Starten ein key pair angeben und dann den privaten Schlüssel des Paares angeben, wenn Sie eine Verbindung herstellen.
Wenn Sie eine EC2-Instance starten, können Sie ein key pair dafür erstellen oder eines verwenden, das Sie bereits beim Starten anderer Instances verwendet haben. Weitere Informationen zu Amazon EC2 EC2-Schlüsselpaaren finden Sie unter [Arbeiten mit Amazon EC2 EC2-Schlüsselpaaren](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) im [Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
Informationen zu den Voraussetzungen APIs und finden Sie im übergeordneten Abschnitt (). [Arbeiten mit Amazon EC2](ec2-apis-intro.md)
**Topics**
+ [Schlüsselpaare erstellen und anzeigen](create-save-key-pair.md)
+ [Schlüsselpaare löschen](delete-key-pairs.md)
# Schlüsselpaare erstellen und anzeigen
Dieses Beispiel zeigt Ihnen, wie Sie AWS SDK für .NET mit dem ein key pair erstellen. Die Anwendung verwendet den Namen für das neue key pair und den Namen einer PEM-Datei (mit der Erweiterung „.pem“). Sie erstellt das Schlüsselpaar, schreibt den privaten Schlüssel in die PEM-Datei und zeigt dann alle verfügbaren Schlüsselpaare an. Wenn Sie keine Befehlszeilenargumente angeben, zeigt die Anwendung einfach alle verfügbaren Schlüsselpaare an.
Die folgenden Abschnitte enthalten Auszüge aus diesem Beispiel. Der [vollständige Code für das Beispiel](#create-save-key-pair-complete-code) wird danach angezeigt und kann unverändert erstellt und ausgeführt werden.
**Topics**
+ [Erstellen des Schlüsselpaars](#create-save-key-pair-create)
+ [Verfügbare Schlüsselpaare anzeigen](#create-save-key-pair-display)
+ [Vollständiger Code](#create-save-key-pair-complete-code)
+ [Weitere Überlegungen](#create-save-key-pair-additional)
## Erstellen des Schlüsselpaars
Das folgende Snippet erstellt ein key pair und speichert dann den privaten Schlüssel in der angegebenen PEM-Datei.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#create-save-key-pair-complete-code) Snippet verwendet wird.
```
//
// Method to create a key pair and save the key material in a PEM file
private static async Task CreateKeyPair(
IAmazonEC2 ec2Client, string keyPairName, string pemFileName)
{
// Create the key pair
CreateKeyPairResponse response =
await ec2Client.CreateKeyPairAsync(new CreateKeyPairRequest{
KeyName = keyPairName
});
Console.WriteLine($"\nCreated new key pair: {response.KeyPair.KeyName}");
// Save the private key in a PEM file
using (var s = new FileStream(pemFileName, FileMode.Create))
using (var writer = new StreamWriter(s))
{
writer.WriteLine(response.KeyPair.KeyMaterial);
}
}
```
## Verfügbare Schlüsselpaare anzeigen
Das folgende Snippet zeigt eine Liste der verfügbaren Schlüsselpaare.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#create-save-key-pair-complete-code) Snippet verwendet wird.
```
//
// Method to show the key pairs that are available
private static async Task EnumerateKeyPairs(IAmazonEC2 ec2Client)
{
DescribeKeyPairsResponse response = await ec2Client.DescribeKeyPairsAsync();
Console.WriteLine("Available key pairs:");
foreach (KeyPairInfo item in response.KeyPairs)
Console.WriteLine($" {item.KeyName}");
}
```
## Vollständiger Code
Dieser Abschnitt enthält relevante Referenzen und den vollständigen Code für dieses Beispiel.
### SDK-Referenzen
NuGet Pakete:
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Elemente der Programmierung:
+ [Namespace Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2.html)
Klasse [EC2Amazon-Kunde](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
+ [Namespace Amazon.EC2.Model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Klasse [CreateKeyPairRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TCreateKeyPairRequest.html)
Klasse [CreateKeyPairResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TCreateKeyPairResponse.html)
Klasse [DescribeKeyPairsResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeKeyPairsResponse.html)
Klasse [KeyPairInfo](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TKeyPairInfo.html)
### Der Code
```
using System;
using System.Threading.Tasks;
using System.IO;
using Amazon.EC2;
using Amazon.EC2.Model;
using System.Collections.Generic;
namespace EC2CreateKeyPair
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to create and store a key pair
class Program
{
static async Task Main(string[] args)
{
// Create the EC2 client
var ec2Client = new AmazonEC2Client();
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if(parsedArgs.Count == 0)
{
// In the case of no command-line arguments,
// just show help and the existing key pairs
PrintHelp();
Console.WriteLine("\nNo arguments specified.");
Console.Write(
"Do you want to see a list of the existing key pairs? ((y) or n): ");
string response = Console.ReadLine();
if((string.IsNullOrEmpty(response)) || (response.ToLower() == "y"))
await EnumerateKeyPairs(ec2Client);
return;
}
// Get the application arguments from the parsed list
string keyPairName =
CommandLine.GetArgument(parsedArgs, null, "-k", "--keypair-name");
string pemFileName =
CommandLine.GetArgument(parsedArgs, null, "-p", "--pem-filename");
if(string.IsNullOrEmpty(keyPairName))
CommandLine.ErrorExit("\nNo key pair name specified." +
"\nRun the command with no arguments to see help.");
if(string.IsNullOrEmpty(pemFileName) || !pemFileName.EndsWith(".pem"))
CommandLine.ErrorExit("\nThe PEM filename is missing or incorrect." +
"\nRun the command with no arguments to see help.");
// Create the key pair
await CreateKeyPair(ec2Client, keyPairName, pemFileName);
await EnumerateKeyPairs(ec2Client);
}
//
// Method to create a key pair and save the key material in a PEM file
private static async Task CreateKeyPair(
IAmazonEC2 ec2Client, string keyPairName, string pemFileName)
{
// Create the key pair
CreateKeyPairResponse response =
await ec2Client.CreateKeyPairAsync(new CreateKeyPairRequest{
KeyName = keyPairName
});
Console.WriteLine($"\nCreated new key pair: {response.KeyPair.KeyName}");
// Save the private key in a PEM file
using (var s = new FileStream(pemFileName, FileMode.Create))
using (var writer = new StreamWriter(s))
{
writer.WriteLine(response.KeyPair.KeyMaterial);
}
}
//
// Method to show the key pairs that are available
private static async Task EnumerateKeyPairs(IAmazonEC2 ec2Client)
{
DescribeKeyPairsResponse response = await ec2Client.DescribeKeyPairsAsync();
Console.WriteLine("Available key pairs:");
foreach (KeyPairInfo item in response.KeyPairs)
Console.WriteLine($" {item.KeyName}");
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine(
"\nUsage: EC2CreateKeyPair -k -p " +
"\n -k, --keypair-name: The name you want to assign to the key pair." +
"\n -p, --pem-filename: The name of the PEM file to create, with a \".pem\" extension.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
## Weitere Überlegungen
+ Nachdem Sie das Beispiel ausgeführt haben, können Sie das neue key pair in der [Amazon EC2 EC2-Konsole](https://console.aws.amazon.com/ec2/#KeyPairs) sehen.
+ Wenn Sie ein key pair erstellen, müssen Sie den zurückgegebenen privaten Schlüssel speichern, da Sie den privaten Schlüssel später nicht abrufen können.
# Schlüsselpaare löschen
Dieses Beispiel zeigt Ihnen, wie Sie mit AWS SDK für .NET dem ein key pair löschen können. Die Anwendung verwendet den Namen eines key pair. Es löscht das key pair und zeigt dann alle verfügbaren Schlüsselpaare an. Wenn Sie keine Befehlszeilenargumente angeben, zeigt die Anwendung einfach alle verfügbaren Schlüsselpaare an.
Die folgenden Abschnitte enthalten Auszüge aus diesem Beispiel. Der [vollständige Code für das Beispiel](#delete-key-pairs-complete-code) wird danach angezeigt und kann unverändert erstellt und ausgeführt werden.
**Topics**
+ [Schlüsselpaare löschen](#delete-key-pairs-create)
+ [Verfügbare Schlüsselpaare anzeigen](#delete-key-pairs-display)
+ [Vollständiger Code](#delete-key-pairs-complete-code)
## Schlüsselpaare löschen
Das folgende Snippet löscht ein key pair.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#delete-key-pairs-complete-code) Snippet verwendet wird.
```
//
// Method to delete a key pair
private static async Task DeleteKeyPair(IAmazonEC2 ec2Client, string keyName)
{
await ec2Client.DeleteKeyPairAsync(new DeleteKeyPairRequest{
KeyName = keyName});
Console.WriteLine($"\nKey pair {keyName} has been deleted (if it existed).");
}
```
## Verfügbare Schlüsselpaare anzeigen
Das folgende Snippet zeigt eine Liste der verfügbaren Schlüsselpaare.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#delete-key-pairs-complete-code) Snippet verwendet wird.
```
//
// Method to show the key pairs that are available
private static async Task EnumerateKeyPairs(IAmazonEC2 ec2Client)
{
DescribeKeyPairsResponse response = await ec2Client.DescribeKeyPairsAsync();
Console.WriteLine("Available key pairs:");
foreach (KeyPairInfo item in response.KeyPairs)
Console.WriteLine($" {item.KeyName}");
}
```
## Vollständiger Code
Dieser Abschnitt enthält relevante Referenzen und den vollständigen Code für dieses Beispiel.
### SDK-Referenzen
NuGet Pakete:
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Elemente der Programmierung:
+ [Namespace Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2.html)
Klasse [EC2Amazon-Kunde](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
+ [Namespace Amazon.EC2.Model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Klasse [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/)
Klasse [DescribeKeyPairsResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeKeyPairsResponse.html)
Klasse [KeyPairInfo](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TKeyPairInfo.html)
### Der Code
```
using System;
using System.Threading.Tasks;
using Amazon.EC2;
using Amazon.EC2.Model;
namespace EC2DeleteKeyPair
{
class Program
{
static async Task Main(string[] args)
{
// Create the EC2 client
var ec2Client = new AmazonEC2Client();
if(args.Length == 1)
{
// Delete a key pair (if it exists)
await DeleteKeyPair(ec2Client, args[0]);
// Display the key pairs that are left
await EnumerateKeyPairs(ec2Client);
}
else
{
Console.WriteLine("\nUsage: EC2DeleteKeyPair keypair-name");
Console.WriteLine(" keypair-name - The name of the key pair you want to delete.");
Console.WriteLine("\nNo arguments specified.");
Console.Write(
"Do you want to see a list of the existing key pairs? ((y) or n): ");
string response = Console.ReadLine();
if((string.IsNullOrEmpty(response)) || (response.ToLower() == "y"))
await EnumerateKeyPairs(ec2Client);
}
}
//
// Method to delete a key pair
private static async Task DeleteKeyPair(IAmazonEC2 ec2Client, string keyName)
{
await ec2Client.DeleteKeyPairAsync(new DeleteKeyPairRequest{
KeyName = keyName});
Console.WriteLine($"\nKey pair {keyName} has been deleted (if it existed).");
}
//
// Method to show the key pairs that are available
private static async Task EnumerateKeyPairs(IAmazonEC2 ec2Client)
{
DescribeKeyPairsResponse response = await ec2Client.DescribeKeyPairsAsync();
Console.WriteLine("Available key pairs:");
foreach (KeyPairInfo item in response.KeyPairs)
Console.WriteLine($" {item.KeyName}");
}
}
}
```
# Ihre Amazon EC2 EC2-Regionen und Availability Zones anzeigen
Amazon EC2 wird an mehreren Standorten weltweit gehostet. Diese Standorte bestehen aus -Regionen und Availability Zones. Jede Region ist ein separates geografisches Gebiet mit mehreren isolierten Standorten, die als Availability Zones bezeichnet werden.
Weitere Informationen zu Regionen und Availability Zones finden Sie unter [Regionen und Zonen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) im [Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
Dieses Beispiel zeigt Ihnen, wie Sie mithilfe von Details AWS SDK für .NET zu den Regionen und Availability Zones eines EC2-Clients abrufen können. Die Anwendung zeigt Listen der Regionen und Availability Zones an, die für einen EC2-Client verfügbar sind.
## SDK-Referenzen
NuGet Pakete:
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Elemente der Programmierung:
+ [Namespace Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2.html)
Klasse [EC2Amazon-Kunde](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
+ [Namespace Amazon.EC2.Model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Klasse [DescribeAvailabilityZonesResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeAvailabilityZonesResponse.html)
Klasse [DescribeRegionsResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeRegionsResponse.html)
Klasse [AvailabilityZone](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TAvailabilityZone.html)
Klasse [Region](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TRegion.html)
```
using System;
using System.Threading.Tasks;
using Amazon.EC2;
using Amazon.EC2.Model;
namespace EC2RegionsAndZones
{
class Program
{
static async Task Main(string[] args)
{
Console.WriteLine(
"Finding the Regions and Availability Zones available to an EC2 client...");
// Create the EC2 client
var ec2Client = new AmazonEC2Client();
// Display the Regions and Availability Zones
await DescribeRegions(ec2Client);
await DescribeAvailabilityZones(ec2Client);
}
//
// Method to display Regions
private static async Task DescribeRegions(IAmazonEC2 ec2Client)
{
Console.WriteLine("\nRegions that are enabled for the EC2 client:");
DescribeRegionsResponse response = await ec2Client.DescribeRegionsAsync();
foreach (Region region in response.Regions)
Console.WriteLine(region.RegionName);
}
//
// Method to display Availability Zones
private static async Task DescribeAvailabilityZones(IAmazonEC2 ec2Client)
{
Console.WriteLine("\nAvailability Zones for the EC2 client's region:");
DescribeAvailabilityZonesResponse response =
await ec2Client.DescribeAvailabilityZonesAsync();
foreach (AvailabilityZone az in response.AvailabilityZones)
Console.WriteLine(az.ZoneName);
}
}
}
```
# Arbeiten mit Amazon EC2 EC2-Instances
Sie können die verwenden AWS SDK für .NET , um Amazon EC2 EC2-Instances mit Vorgängen wie Erstellen, Starten und Beenden zu steuern. Die Themen in diesem Abschnitt enthalten einige Beispiele dafür, wie Sie dies tun können. Weitere Informationen zu EC2-Instances finden Sie unter [Amazon EC2 EC2-Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Instances.html) im [Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
Informationen zu den Voraussetzungen APIs und Voraussetzungen finden Sie im übergeordneten Abschnitt (). [Arbeiten mit Amazon EC2](ec2-apis-intro.md)
**Topics**
+ [Starten einer EC2-Instance](run-instance.md)
+ [Beenden einer EC2-Instance](terminate-instance.md)
# Starten einer Amazon EC2 EC2-Instance
Dieses Beispiel zeigt Ihnen, wie Sie die verwenden AWS SDK für .NET , um eine oder mehrere identisch konfigurierte Amazon EC2 EC2-Instances von demselben Amazon Machine Image (AMI) aus zu starten. Unter Verwendung [mehrerer von Ihnen eingegebener Eingaben](#run-instance-gather) startet die Anwendung eine EC2-Instance und überwacht die Instance dann, bis sie den Status „Ausstehend“ erreicht hat.
Wenn Ihre EC2-Instance läuft, können Sie eine Remoteverbindung zu ihr herstellen, wie unter beschrieben. [(optional) Connect zur Instanz her](#connect-to-instance)
**Warnung**
EC2-Classic wurde am 15. August 2022 außer Betrieb genommen. Wir empfehlen Ihnen die Migration von EC2-Classic zu einer VPC. Weitere Informationen finden Sie im Blogbeitrag [EC2-Classic Networking is Retiring — So bereiten Sie sich](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/) vor.
Die folgenden Abschnitte enthalten Auszüge und andere Informationen zu diesem Beispiel. Der [vollständige Code für das Beispiel](#run-instance-complete-code) wird hinter den Codefragmenten angezeigt und kann unverändert erstellt und ausgeführt werden.
**Topics**
+ [Sammle, was du brauchst](#run-instance-gather)
+ [Starten einer -Instance](#run-instance-launch)
+ [Überwachen Sie die Instanz](#run-instance-monitor)
+ [Vollständiger Code](#run-instance-complete-code)
+ [Weitere Überlegungen](#run-instance-additional)
+ [(optional) Connect zur Instanz her](#connect-to-instance)
+ [Bereinigen](#run-instance-cleanup)
## Sammle, was du brauchst
Um eine EC2-Instance zu starten, benötigen Sie mehrere Dinge.
+ Eine [VPC](https://docs.aws.amazon.com/vpc/latest/userguide/), auf der die Instance gestartet wird. Wenn es sich um eine Windows-Instance handelt und Sie über RDP eine Verbindung zu ihr herstellen, muss an die VPC höchstwahrscheinlich ein Internet-Gateway sowie ein Eintrag für das Internet-Gateway in der Routing-Tabelle angeschlossen sein. Weitere Informationen finden Sie unter [Internet-Gateways](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html) im *Benutzerhandbuch für Amazon VPC*.
+ Die ID eines vorhandenen Subnetzes in der VPC, in dem die Instance gestartet wird. Eine einfache Möglichkeit, dies zu finden oder zu erstellen, besteht darin, sich [bei der Amazon VPC-Konsole](https://console.aws.amazon.com/vpc/home#subnets) anzumelden. Sie können es aber auch programmgesteuert abrufen, indem Sie die [CreateSubnetAsync](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/MEC2CreateSubnetAsyncCreateSubnetRequestCancellationToken.html)Methoden und verwenden. [DescribeSubnetsAsync](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/MEC2DescribeSubnetsAsyncDescribeSubnetsRequestCancellationToken.html)
**Anmerkung**
Wenn Sie diesen Parameter nicht angeben, wird die neue Instance in der Standard-VPC für Ihr Konto gestartet.
+ Die ID einer vorhandenen Sicherheitsgruppe, die zu der VPC gehört, in der die Instance gestartet wird. Weitere Informationen finden Sie unter [Arbeiten mit Sicherheitsgruppen in Amazon EC2](security-groups.md).
+ Wenn Sie eine Verbindung mit der neuen Instanz herstellen möchten, muss die zuvor erwähnte Sicherheitsgruppe über eine entsprechende Regel für eingehenden Datenverkehr verfügen, die SSH-Verkehr auf Port 22 (Linux-Instanz) oder RDP-Verkehr auf Port 3389 (Windows-Instanz) zulässt. Informationen dazu finden Sie unter[Sicherheitsgruppen werden aktualisiert](authorize-ingress.md), auch am Ende dieses [Weitere Überlegungen](authorize-ingress.md#authorize-ingress-additional) Themas.
+ Das Amazon Machine Image (AMI), das zur Erstellung der Instance verwendet wird. Weitere Informationen dazu AMIs finden Sie unter [Amazon Machine Images (AMIs)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) im [Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/). Insbesondere siehe [Find an AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/finding-an-ami.html) and [Shared AMIs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/sharing-amis.html).
+ Der Name eines vorhandenen EC2-Schlüsselpaars, das für die Verbindung mit der neuen Instance verwendet wird. Weitere Informationen finden Sie unter [Arbeiten mit Amazon EC2 EC2-Schlüsselpaaren](key-pairs.md).
+ Der Name der PEM-Datei, die den privaten Schlüssel des zuvor erwähnten EC2-Schlüsselpaars enthält. Die PEM-Datei wird verwendet, wenn Sie eine [Remoteverbindung mit der Instance herstellen](#connect-to-instance).
## Starten einer -Instance
Das folgende Snippet startet eine EC2-Instance.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#run-instance-complete-code) Snippet verwendet wird.
```
//
// Method to launch the instances
// Returns a list with the launched instance IDs
private static async Task> LaunchInstances(
IAmazonEC2 ec2Client, RunInstancesRequest requestLaunch)
{
var instanceIds = new List();
RunInstancesResponse responseLaunch =
await ec2Client.RunInstancesAsync(requestLaunch);
Console.WriteLine("\nNew instances have been created.");
foreach (Instance item in responseLaunch.Reservation.Instances)
{
instanceIds.Add(item.InstanceId);
Console.WriteLine($" New instance: {item.InstanceId}");
}
return instanceIds;
}
```
## Überwachen Sie die Instanz
Das folgende Snippet überwacht die Instanz, bis sie den Status „Ausstehend“ erreicht hat.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#run-instance-complete-code) Snippet verwendet wird.
Die gültigen Werte der Eigenschaft finden Sie in der [InstanceState](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TInstanceState.html)`Instance.State.Code`Klasse.
```
//
// Method to wait until the instances are running (or at least not pending)
private static async Task CheckState(IAmazonEC2 ec2Client, List instanceIds)
{
Console.WriteLine(
"\nWaiting for the instances to start." +
"\nPress any key to stop waiting. (Response might be slightly delayed.)");
int numberRunning;
DescribeInstancesResponse responseDescribe;
var requestDescribe = new DescribeInstancesRequest{
InstanceIds = instanceIds};
// Check every couple of seconds
int wait = 2000;
while(true)
{
// Get and check the status for each of the instances to see if it's past pending.
// Once all instances are past pending, break out.
// (For this example, we are assuming that there is only one reservation.)
Console.Write(".");
numberRunning = 0;
responseDescribe = await ec2Client.DescribeInstancesAsync(requestDescribe);
foreach(Instance i in responseDescribe.Reservations[0].Instances)
{
// Check the lower byte of State.Code property
// Code == 0 is the pending state
if((i.State.Code & 255) > 0) numberRunning++;
}
if(numberRunning == responseDescribe.Reservations[0].Instances.Count)
break;
// Wait a bit and try again (unless the user wants to stop waiting)
Thread.Sleep(wait);
if(Console.KeyAvailable)
break;
}
Console.WriteLine("\nNo more instances are pending.");
foreach(Instance i in responseDescribe.Reservations[0].Instances)
{
Console.WriteLine($"For {i.InstanceId}:");
Console.WriteLine($" VPC ID: {i.VpcId}");
Console.WriteLine($" Instance state: {i.State.Name}");
Console.WriteLine($" Public IP address: {i.PublicIpAddress}");
Console.WriteLine($" Public DNS name: {i.PublicDnsName}");
Console.WriteLine($" Key pair name: {i.KeyName}");
}
}
```
## Vollständiger Code
Dieser Abschnitt enthält relevante Referenzen und den vollständigen Code für dieses Beispiel.
### SDK-Referenzen
NuGet Pakete:
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Elemente der Programmierung:
+ [Namespace Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2.html)
Klasse [EC2Amazon-Kunde](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
Klasse [InstanceType](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TInstanceType.html)
+ [Namespace Amazon.EC2.Model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Klasse [DescribeInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeInstancesRequest.html)
Klasse [DescribeInstancesResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeInstancesResponse.html)
[Klasseninstanz](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TInstance.html)
Klasse [InstanceNetworkInterfaceSpecification](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TInstanceNetworkInterfaceSpecification.html)
Klasse [RunInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TRunInstancesRequest.html)
Klasse [RunInstancesResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TRunInstancesResponse.html)
### Der Code
```
using System;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using Amazon.EC2;
using Amazon.EC2.Model;
namespace EC2LaunchInstance
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to launch an EC2 instance
class Program
{
static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if(parsedArgs.Count == 0)
{
PrintHelp();
return;
}
// Get the application arguments from the parsed list
string groupID =
CommandLine.GetArgument(parsedArgs, null, "-g", "--group-id");
string ami =
CommandLine.GetArgument(parsedArgs, null, "-a", "--ami-id");
string keyPairName =
CommandLine.GetArgument(parsedArgs, null, "-k", "--keypair-name");
string subnetID =
CommandLine.GetArgument(parsedArgs, null, "-s", "--subnet-id");
if( (string.IsNullOrEmpty(groupID) || !groupID.StartsWith("sg-"))
|| (string.IsNullOrEmpty(ami) || !ami.StartsWith("ami-"))
|| (string.IsNullOrEmpty(keyPairName))
|| (!string.IsNullOrEmpty(subnetID) && !subnetID.StartsWith("subnet-")))
CommandLine.ErrorExit(
"\nOne or more of the required arguments is missing or incorrect." +
"\nRun the command with no arguments to see help.");
// Create an EC2 client
var ec2Client = new AmazonEC2Client();
// Create an object with the necessary properties
RunInstancesRequest request = GetRequestData(groupID, ami, keyPairName, subnetID);
// Launch the instances and wait for them to start running
var instanceIds = await LaunchInstances(ec2Client, request);
await CheckState(ec2Client, instanceIds);
}
//
// Method to put together the properties needed to launch the instance.
private static RunInstancesRequest GetRequestData(
string groupID, string ami, string keyPairName, string subnetID)
{
// Common properties
var groupIDs = new List() { groupID };
var request = new RunInstancesRequest()
{
// The first three of these would be additional command-line arguments or similar.
InstanceType = InstanceType.T1Micro,
MinCount = 1,
MaxCount = 1,
ImageId = ami,
KeyName = keyPairName
};
// Properties specifically for EC2 in a VPC.
if(!string.IsNullOrEmpty(subnetID))
{
request.NetworkInterfaces =
new List() {
new InstanceNetworkInterfaceSpecification() {
DeviceIndex = 0,
SubnetId = subnetID,
Groups = groupIDs,
AssociatePublicIpAddress = true
}
};
}
// Properties specifically for EC2-Classic
else
{
request.SecurityGroupIds = groupIDs;
}
return request;
}
//
// Method to launch the instances
// Returns a list with the launched instance IDs
private static async Task> LaunchInstances(
IAmazonEC2 ec2Client, RunInstancesRequest requestLaunch)
{
var instanceIds = new List();
RunInstancesResponse responseLaunch =
await ec2Client.RunInstancesAsync(requestLaunch);
Console.WriteLine("\nNew instances have been created.");
foreach (Instance item in responseLaunch.Reservation.Instances)
{
instanceIds.Add(item.InstanceId);
Console.WriteLine($" New instance: {item.InstanceId}");
}
return instanceIds;
}
//
// Method to wait until the instances are running (or at least not pending)
private static async Task CheckState(IAmazonEC2 ec2Client, List instanceIds)
{
Console.WriteLine(
"\nWaiting for the instances to start." +
"\nPress any key to stop waiting. (Response might be slightly delayed.)");
int numberRunning;
DescribeInstancesResponse responseDescribe;
var requestDescribe = new DescribeInstancesRequest{
InstanceIds = instanceIds};
// Check every couple of seconds
int wait = 2000;
while(true)
{
// Get and check the status for each of the instances to see if it's past pending.
// Once all instances are past pending, break out.
// (For this example, we are assuming that there is only one reservation.)
Console.Write(".");
numberRunning = 0;
responseDescribe = await ec2Client.DescribeInstancesAsync(requestDescribe);
foreach(Instance i in responseDescribe.Reservations[0].Instances)
{
// Check the lower byte of State.Code property
// Code == 0 is the pending state
if((i.State.Code & 255) > 0) numberRunning++;
}
if(numberRunning == responseDescribe.Reservations[0].Instances.Count)
break;
// Wait a bit and try again (unless the user wants to stop waiting)
Thread.Sleep(wait);
if(Console.KeyAvailable)
break;
}
Console.WriteLine("\nNo more instances are pending.");
foreach(Instance i in responseDescribe.Reservations[0].Instances)
{
Console.WriteLine($"For {i.InstanceId}:");
Console.WriteLine($" VPC ID: {i.VpcId}");
Console.WriteLine($" Instance state: {i.State.Name}");
Console.WriteLine($" Public IP address: {i.PublicIpAddress}");
Console.WriteLine($" Public DNS name: {i.PublicDnsName}");
Console.WriteLine($" Key pair name: {i.KeyName}");
}
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine(
"\nUsage: EC2LaunchInstance -g -a -k [-s ]" +
"\n -g, --group-id: The ID of the security group." +
"\n -a, --ami-id: The ID of an Amazon Machine Image." +
"\n -k, --keypair-name - The name of a key pair." +
"\n -s, --subnet-id: The ID of a subnet. Required only for EC2 in a VPC.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
## Weitere Überlegungen
+ Wenn Sie den Status einer EC2-Instance überprüfen, können Sie der `Filter` Eigenschaft des [DescribeInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeInstancesRequest.html)Objekts einen Filter hinzufügen. Mit dieser Technik können Sie die Anfrage auf bestimmte Instanzen beschränken, z. B. auf Instanzen mit einem bestimmten benutzerdefinierten Tag.
+ Der Kürze halber wurden einigen Eigenschaften typische Werte zugewiesen. Einige oder alle dieser Eigenschaften können stattdessen programmgesteuert oder durch Benutzereingaben bestimmt werden.
+ Die Werte, die Sie für die `MaxCount` Eigenschaften `MinCount` und des [RunInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TRunInstancesRequest.html)Objekts verwenden können, werden durch die Ziel-Availability Zone und die maximale Anzahl von Instanzen bestimmt, die Sie für den Instance-Typ verwenden können. Weitere Informationen finden Sie unter [Wie viele Instances kann ich in Amazon EC2 ausführen in](https://aws.amazon.com/ec2/faqs/#How_many_instances_can_I_run_in_Amazon_EC2) den Allgemeinen Häufig gestellten Fragen zu Amazon EC2.
+ Wenn Sie einen anderen Instance-Typ als dieses Beispiel verwenden möchten, stehen Ihnen mehrere Instance-Typen zur Auswahl. Weitere Informationen finden Sie unter [Amazon EC2 EC2-Instance-Typen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) im [Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/). Weitere Informationen finden Sie unter [Details zum Instanztyp](https://aws.amazon.com/ec2/instance-types/) und [Instanztyp-Explorer](https://aws.amazon.com/ec2/instance-explorer/).
+ Sie können einer Instance auch eine [IAM-Rolle](net-dg-hosm.md) zuordnen, wenn Sie sie starten. Erstellen Sie dazu ein [IamInstanceProfileSpecification](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TIamInstanceProfileSpecification.html)Objekt, dessen `Name` Eigenschaft auf den Namen einer IAM-Rolle gesetzt ist. Fügen Sie dieses Objekt dann der `IamInstanceProfile` Eigenschaft des [RunInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TRunInstancesRequest.html)Objekts hinzu.
**Anmerkung**
Um eine EC2-Instance zu starten, der eine IAM-Rolle zugewiesen ist, muss die Konfiguration eines IAM-Benutzers bestimmte Berechtigungen enthalten. Weitere Informationen zu den erforderlichen Berechtigungen finden Sie im [Amazon EC2 EC2-Benutzerhandbuch unter Gewähren Sie einem Benutzer](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/) [die Berechtigung, eine IAM-Rolle an eine Instance zu übergeben](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#permission-to-pass-iam-roles).
## (optional) Connect zur Instanz her
Nachdem eine Instanz ausgeführt wurde, können Sie mithilfe des entsprechenden Remote-Clients eine Remoteverbindung zu ihr herstellen. Sowohl für Linux- als auch für Windows-Instances benötigen Sie die öffentliche IP-Adresse oder den öffentlichen DNS-Namen der Instanz. Sie benötigen außerdem Folgendes.
**Für Linux-Instances**
Sie können einen SSH-Client verwenden, um eine Verbindung zu Ihrer Linux-Instance herzustellen. Stellen Sie sicher, dass die Sicherheitsgruppe, die Sie beim Start der Instance verwendet haben, SSH-Verkehr auf Port 22 zulässt, wie unter beschrieben. [Sicherheitsgruppen werden aktualisiert](authorize-ingress.md)
Sie benötigen auch den privaten Teil des key pair, das Sie zum Starten der Instance verwendet haben, d. h. die PEM-Datei.
Weitere Informationen finden Sie unter [Connect to your Linux Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html) im Amazon EC2 EC2-Benutzerhandbuch.
**Für Windows-Instances**
Sie können einen RDP-Client verwenden, um eine Verbindung zu Ihrer Instance herzustellen. Stellen Sie sicher, dass die Sicherheitsgruppe, die Sie beim Start der Instance verwendet haben, RDP-Verkehr auf Port 3389 zulässt, wie unter beschrieben. [Sicherheitsgruppen werden aktualisiert](authorize-ingress.md)
Sie benötigen außerdem das Administratorkennwort. Sie können dies mithilfe des folgenden Beispielcodes abrufen, für den die Instanz-ID und der private Teil des key pair erforderlich sind, das zum Starten der Instance verwendet wurde, d. h. die PEM-Datei.
Weitere Informationen finden Sie unter [Connect to your Windows Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connecting_to_windows_instance.html) im Amazon EC2 EC2-Benutzerhandbuch.
**Warnung**
Dieser Beispielcode gibt das Administratorkennwort im Klartext für Ihre Instance zurück.
### SDK-Referenzen
NuGet Pakete:
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Elemente der Programmierung:
+ [Namespace Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2.html)
Klasse [EC2Amazon-Kunde](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
+ [Namespace Amazon.EC2.Model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Klasse [GetPasswordDataRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TGetPasswordDataRequest.html)
Klasse [GetPasswordDataResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TGetPasswordDataResponse.html)
### Der Code
```
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Amazon.EC2;
using Amazon.EC2.Model;
namespace EC2GetWindowsPassword
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to get the Administrator password of a Windows EC2 instance
class Program
{
static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if(parsedArgs.Count == 0)
{
PrintHelp();
return;
}
// Get the application arguments from the parsed list
string instanceID =
CommandLine.GetArgument(parsedArgs, null, "-i", "--instance-id");
string pemFileName =
CommandLine.GetArgument(parsedArgs, null, "-p", "--pem-filename");
if( (string.IsNullOrEmpty(instanceID) || !instanceID.StartsWith("i-"))
|| (string.IsNullOrEmpty(pemFileName) || !pemFileName.EndsWith(".pem")))
CommandLine.ErrorExit(
"\nOne or more of the required arguments is missing or incorrect." +
"\nRun the command with no arguments to see help.");
// Create the EC2 client
var ec2Client = new AmazonEC2Client();
// Get and display the password
string password = await GetPassword(ec2Client, instanceID, pemFileName);
Console.WriteLine($"\nPassword: {password}");
}
//
// Method to get the administrator password of a Windows EC2 instance
private static async Task GetPassword(
IAmazonEC2 ec2Client, string instanceID, string pemFilename)
{
string password = string.Empty;
GetPasswordDataResponse response =
await ec2Client.GetPasswordDataAsync(new GetPasswordDataRequest{
InstanceId = instanceID});
if(response.PasswordData != null)
{
password = response.GetDecryptedPassword(File.ReadAllText(pemFilename));
}
else
{
Console.WriteLine($"\nThe password is not available for instance {instanceID}.");
Console.WriteLine($"If this is a Windows instance, the password might not be ready.");
}
return password;
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine(
"\nUsage: EC2GetWindowsPassword -i -p pem-filename" +
"\n -i, --instance-id: The name of the EC2 instance." +
"\n -p, --pem-filename: The name of the PEM file with the private key.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
## Bereinigen
Wenn Sie Ihre EC2-Instance nicht mehr benötigen, beenden Sie sie unbedingt, wie unter beschrieben[Beenden einer Amazon EC2 EC2-Instance](terminate-instance.md).
# Beenden einer Amazon EC2 EC2-Instance
Wenn Sie eine oder mehrere Ihrer Amazon EC2 EC2-Instances nicht mehr benötigen, können Sie sie kündigen.
Dieses Beispiel zeigt Ihnen, wie Sie die verwenden, um AWS SDK für .NET EC2-Instances zu beenden. Es verwendet eine Instanz-ID als Eingabe.
## SDK-Referenzen
NuGet Pakete:
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Elemente der Programmierung:
+ [Namespace Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2.html)
Klasse [EC2Amazon-Kunde](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
+ [Namespace Amazon.EC2.Model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Klasse [TerminateInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TTerminateInstancesRequest.html)
Klasse [TerminateInstancesResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TTerminateInstancesResponse.html)
```
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using Amazon.EC2;
using Amazon.EC2.Model;
namespace EC2TerminateInstance
{
class Program
{
static async Task Main(string[] args)
{
if((args.Length == 1) && (args[0].StartsWith("i-")))
{
// Terminate the instance
var ec2Client = new AmazonEC2Client();
await TerminateInstance(ec2Client, args[0]);
}
else
{
Console.WriteLine("\nCommand-line argument missing or incorrect.");
Console.WriteLine("\nUsage: EC2TerminateInstance instance-ID");
Console.WriteLine(" instance-ID - The EC2 instance you want to terminate.");
return;
}
}
//
// Method to terminate an EC2 instance
private static async Task TerminateInstance(IAmazonEC2 ec2Client, string instanceID)
{
var request = new TerminateInstancesRequest{
InstanceIds = new List() { instanceID }};
TerminateInstancesResponse response =
await ec2Client.TerminateInstancesAsync(new TerminateInstancesRequest{
InstanceIds = new List() { instanceID }
});
foreach (InstanceStateChange item in response.TerminatingInstances)
{
Console.WriteLine("Terminated instance: " + item.InstanceId);
Console.WriteLine("Instance state: " + item.CurrentState.Name);
}
}
}
}
```
Nachdem Sie das Beispiel ausgeführt haben, empfiehlt es sich, sich [bei der Amazon EC2-Konsole](https://console.aws.amazon.com/ec2/) anzumelden, um zu überprüfen, ob die [EC2-Instance beendet](https://console.aws.amazon.com/ec2/v2/home#Instances) wurde.
# Anleitung zur Amazon EC2-Spot-Instance
Dieses Tutorial zeigt Ihnen, wie Sie Amazon EC2-Spot-Instances verwalten. AWS SDK für .NET
## -Übersicht
Spot-Instances ermöglichen es Ihnen, ungenutzte Amazon EC2 EC2-Kapazität für weniger als den On-Demand-Preis anzufordern. Dies kann Ihre EC2-Kosten für Anwendungen, die unterbrochen werden können, erheblich senken.
Im Folgenden finden Sie eine allgemeine Zusammenfassung darüber, wie Spot-Instances angefordert und verwendet werden.
1. Erstellen Sie eine Spot-Instance-Anfrage und geben Sie den Höchstpreis an, den Sie zu zahlen bereit sind.
1. Wenn die Anforderung erfüllt ist, führen Sie die Instance wie jede andere Amazon EC2 EC2-Instance aus.
1. Führen Sie die Instance so lange aus, wie Sie möchten, und beenden Sie sie dann, sofern sich der *Spot-Preis* nicht so ändert, dass die Instance für Sie beendet wird.
1. Bereinigen Sie die Spot-Instance-Anfrage, wenn Sie sie nicht mehr benötigen, sodass keine Spot-Instances mehr erstellt werden.
Dies war ein sehr allgemeiner Überblick über Spot-Instances. Weitere Informationen zu Spot-Instances finden Sie unter [Spot-Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances.html) im [Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
## Über dieses Tutorial
Wenn Sie diesem Tutorial folgen, verwenden Sie den, AWS SDK für .NET um Folgendes zu tun:
+ Erstellt eine Spot-Instance-Anforderung
+ Ermitteln Sie, wann die Spot-Instance-Anfrage erfüllt wurde
+ Stornieren Sie die Spot-Instance-Anfrage
+ Beenden von dazugehörigen Instances
Die folgenden Abschnitte enthalten Auszüge und andere Informationen für dieses Beispiel. Der [vollständige Code für das Beispiel](#tutor-spot-net-main) wird hinter den Codefragmenten angezeigt und kann unverändert erstellt und ausgeführt werden.
**Topics**
+ [-Übersicht](#tutor-spot-net-overview)
+ [Über dieses Tutorial](#about-spot-instances-tutorial)
+ [Voraussetzungen](#tutor-spot-net-prereq)
+ [Sammeln Sie, was Sie benötigen](#tutor-spot-net-gather)
+ [Eine Spot-Instance-Anfrage erstellen](#tutor-spot-net-submit)
+ [Ermitteln Sie den Status Ihrer Spot-Instance-Anfrage](#tutor-spot-net-request-state)
+ [Bereinigen Sie Ihre Spot-Instance-Anfragen](#tutor-spot-net-clean-up-request)
+ [Bereinigen Sie Ihre Spot-Instances](#tutor-spot-net-clean-up-instance)
+ [Vollständiger Code](#tutor-spot-net-main)
+ [Weitere Überlegungen](#tutor-spot-net-additional)
## Voraussetzungen
Informationen zu den Voraussetzungen APIs und den Voraussetzungen finden Sie im übergeordneten Abschnitt ()[Arbeiten mit Amazon EC2](ec2-apis-intro.md).
## Sammeln Sie, was Sie benötigen
Um eine Spot-Instance-Anfrage zu erstellen, benötigen Sie mehrere Dinge.
+ Die Anzahl der Instances und ihr Instance-Typ. Es stehen mehrere Instance-Typen zur Auswahl. Weitere Informationen finden Sie unter [Amazon EC2 EC2-Instance-Typen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) im [Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/). Weitere Informationen finden Sie unter [Details zum Instanztyp](https://aws.amazon.com/ec2/instance-types/) und [Instanztyp-Explorer](https://aws.amazon.com/ec2/instance-explorer/).
Die Standardzahl für dieses Tutorial ist 1.
+ Das Amazon Machine Image (AMI), das zur Erstellung der Instance verwendet wird. Weitere Informationen dazu AMIs finden Sie unter [Amazon Machine Images (AMIs)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) im [Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/). Insbesondere siehe [Find an AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/finding-an-ami.html) and [Shared AMIs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/sharing-amis.html).
+ Der Höchstpreis, den Sie pro Instance-Stunde zu zahlen bereit sind. Sie können die Preise für alle Instance-Typen (sowohl für On-Demand-Instances als auch für Spot-Instances) auf der [Amazon EC2 EC2-Preisseite](https://aws.amazon.com/ec2/pricing/) einsehen. Der Standardpreis für dieses Tutorial wird später erklärt.
+ Wenn Sie eine Remoteverbindung zu einer Instance herstellen möchten, eine Sicherheitsgruppe mit der entsprechenden Konfiguration und den entsprechenden Ressourcen. Eine Beschreibung dazu finden Sie unter [Arbeiten mit Sicherheitsgruppen in Amazon EC2](security-groups.md) und die Informationen zum [Sammeln der benötigten Daten und zum Herstellen einer [Verbindung zu einer Instanz](run-instance.md#connect-to-instance) finden Sie](run-instance.md#run-instance-gather) unter[Starten einer Amazon EC2 EC2-Instance](run-instance.md). Der Einfachheit halber wird in diesem Tutorial die Sicherheitsgruppe mit dem Namen **default** verwendet, über die alle neueren AWS Konten verfügen.
Es gibt viele Möglichkeiten zum Anfordern von Spot-Instances. Die folgenden Strategien sind gebräuchlich:
+ Stellen Sie Anfragen, die mit Sicherheit weniger kosten als On-Demand-Preise.
+ Stellen Sie Anfragen auf der Grundlage des Werts der resultierenden Berechnung.
+ Stellen Sie Anfragen, um so schnell wie möglich Rechenkapazität zu erwerben.
Die folgenden Erläuterungen beziehen sich auf die [Preisentwicklung für Spot-Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances-history.html) im [Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
### Senken Sie die Kosten auf einen Wert unter
Sie haben eine Stapelverarbeitungsaufgabe, die einige Stunden oder Tage laufen wird. Allerdings sind Sie flexibel, was den Start und Abschluss angeht. Sie möchten die Aufgabe nach Möglichkeit günstiger als mit On-Demand-Instances abschließen.
Sie untersuchen den Spot-Price-Verlauf für Instance-Typen, indem Sie entweder die Amazon EC2 EC2-Konsole oder die Amazon EC2 EC2-API verwenden. Nachdem Sie den Preisverlauf für Ihren gewünschten Instance-Typ in einer bestimmten Availability Zone analysiert haben, gibt es zwei alternative Ansätze für Ihr Gebot:
+ Geben Sie eine Anfrage am oberen Ende der Spanne der Spot-Preise an, die immer noch unter dem On-Demand-Preis liegen, und gehen Sie davon aus, dass Ihre einmalige Spot-Instance-Anfrage höchstwahrscheinlich erfüllt und für genügend aufeinanderfolgende Rechenzeit ausgeführt wird, um den Job abzuschließen.
+ Oder Sie geben ein Gebot am unteren Ende der Preisskala ab und planen die Kombination vieler Instances, die im Laufe der Zeit über eine persistente Anforderung starten. Die Instances würden zusammengenommen lange genug laufen, um die Aufgabe sogar zu noch geringeren Gesamtkosten abzuschließen.
### Zahlen Sie nicht mehr als den Wert des Ergebnisses
Sie haben eine Aufgabe zur Datenverarbeitung, die ausgeführt werden soll. Sie kennen den Wert der Ergebnisse des Jobs gut genug, um zu wissen, wie viel sie in Bezug auf die Computerkosten wert sind.
Nachdem Sie den Spot-Price-Verlauf für Ihren Instance-Typ analysiert haben, wählen Sie einen Preis aus, bei dem die Kosten für die Rechenzeit nicht höher sind als der Wert der Ergebnisse des Jobs. Sie erstellen eine persistente Anforderung und lassen es zwischenzeitlich laufen, sobald der Spot-Preis Ihr Gebot erreicht ist oder darunter sinkt.
### Erwerben Sie schnell Rechenkapazität
Sie haben einen unvorhergesehenen, kurzfristigen Bedarf an zusätzlicher Kapazität, der über On-Demand-Instances nicht verfügbar ist. Nachdem Sie den Spot-Price-Verlauf für Ihren Instance-Typ analysiert haben, wählen Sie einen Preis, der über dem höchsten historischen Preis liegt, um die Wahrscheinlichkeit zu erhöhen, dass Ihre Anfrage schnell bearbeitet wird, und setzen die Datenverarbeitung fort, bis sie abgeschlossen ist.
Nachdem Sie alles Notwendige zusammengetragen und eine Strategie ausgewählt haben, können Sie eine Spot-Instance anfordern. Für dieses Tutorial wird der standardmäßige Höchstpreis einer Spot-Instance mit dem On-Demand-Preis (in diesem Tutorial 0,003 USD) festgelegt. Indem der Preises auf diese Weise festgelegt wird, erhöhen sich die Chancen zur Erfüllung der Anfrage.
## Eine Spot-Instance-Anfrage erstellen
Der folgende Ausschnitt zeigt Ihnen, wie Sie eine Spot-Instance-Anfrage mit den zuvor gesammelten Elementen erstellen.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#tutor-spot-net-main) Snippet verwendet wird.
```
//
// Method to create a Spot Instance request
private static async Task CreateSpotInstanceRequest(
IAmazonEC2 ec2Client, string amiId, string securityGroupName,
InstanceType instanceType, string spotPrice, int instanceCount)
{
var launchSpecification = new LaunchSpecification{
ImageId = amiId,
InstanceType = instanceType
};
launchSpecification.SecurityGroups.Add(securityGroupName);
var request = new RequestSpotInstancesRequest{
SpotPrice = spotPrice,
InstanceCount = instanceCount,
LaunchSpecification = launchSpecification
};
RequestSpotInstancesResponse result =
await ec2Client.RequestSpotInstancesAsync(request);
return result.SpotInstanceRequests[0];
}
```
Der wichtige Wert, der von dieser Methode zurückgegeben wird, ist die Spot-Instance-Anforderungs-ID, die im `SpotInstanceRequestId` Element des zurückgegebenen [SpotInstanceRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TSpotInstanceRequest.html)Objekts enthalten ist.
**Anmerkung**
Ihnen werden alle Spot-Instances in Rechnung gestellt, die gestartet werden. Um unnötige Kosten zu vermeiden, sollten Sie [alle Anfragen stornieren](#tutor-spot-net-clean-up-request) und [alle Instances beenden](#tutor-spot-net-clean-up-instance).
## Ermitteln Sie den Status Ihrer Spot-Instance-Anfrage
Der folgende Ausschnitt zeigt Ihnen, wie Sie Informationen zu Ihrer Spot-Instance-Anfrage erhalten. Sie können diese Informationen verwenden, um bestimmte Entscheidungen in Ihrem Code zu treffen, z. B. ob Sie weiterhin auf die Erfüllung einer Spot-Instance-Anfrage warten möchten.
Das Beispiel [am Ende dieses Themas](#tutor-spot-net-main) zeigt, wie dieser Codeausschnitt verwendet wird.
```
//
// Method to get information about a Spot Instance request, including the status,
// instance ID, etc.
// It gets the information for a specific request (as opposed to all requests).
private static async Task GetSpotInstanceRequestInfo(
IAmazonEC2 ec2Client, string requestId)
{
var describeRequest = new DescribeSpotInstanceRequestsRequest();
describeRequest.SpotInstanceRequestIds.Add(requestId);
DescribeSpotInstanceRequestsResponse describeResponse =
await ec2Client.DescribeSpotInstanceRequestsAsync(describeRequest);
return describeResponse.SpotInstanceRequests[0];
}
```
Die Methode gibt Informationen über die Spot-Instance-Anfrage zurück, z. B. die Instance-ID, ihren Status und den Statuscode. Weitere Informationen zu den Statuscodes für Spot-Instance-Anfragen finden Sie unter [Spot-Anforderungsstatus](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-bid-status.html#spot-instance-bid-status-understand) im [Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
## Bereinigen Sie Ihre Spot-Instance-Anfragen
Wenn Sie Spot-Instances nicht mehr anfordern müssen, ist es wichtig, alle ausstehenden Anfragen zu stornieren, um zu verhindern, dass diese Anfragen erneut bearbeitet werden. Der folgende Ausschnitt zeigt Ihnen, wie Sie eine Spot-Instance-Anfrage stornieren.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#tutor-spot-net-main) Snippet verwendet wird.
```
//
// Method to cancel a Spot Instance request
private static async Task CancelSpotInstanceRequest(
IAmazonEC2 ec2Client, string requestId)
{
var cancelRequest = new CancelSpotInstanceRequestsRequest();
cancelRequest.SpotInstanceRequestIds.Add(requestId);
await ec2Client.CancelSpotInstanceRequestsAsync(cancelRequest);
}
```
## Bereinigen Sie Ihre Spot-Instances
Um unnötige Kosten zu vermeiden, ist es wichtig, dass Sie alle Instances beenden, die über Spot-Instance-Anfragen gestartet wurden. Durch das einfache Stornieren von Spot-Instance-Anfragen werden Ihre Instances nicht beendet, was bedeutet, dass Ihnen diese weiterhin in Rechnung gestellt werden. Der folgende Ausschnitt zeigt Ihnen, wie Sie eine Instance beenden, nachdem Sie die Instance-ID für eine aktive Spot-Instance erhalten haben.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#tutor-spot-net-main) Snippet verwendet wird.
```
//
// Method to terminate a Spot Instance
private static async Task TerminateSpotInstance(
IAmazonEC2 ec2Client, string requestId)
{
var describeRequest = new DescribeSpotInstanceRequestsRequest();
describeRequest.SpotInstanceRequestIds.Add(requestId);
// Retrieve the Spot Instance request to check for running instances.
DescribeSpotInstanceRequestsResponse describeResponse =
await ec2Client.DescribeSpotInstanceRequestsAsync(describeRequest);
// If there are any running instances, terminate them
if( (describeResponse.SpotInstanceRequests[0].Status.Code
== "request-canceled-and-instance-running")
|| (describeResponse.SpotInstanceRequests[0].State == SpotInstanceState.Active))
{
TerminateInstancesResponse response =
await ec2Client.TerminateInstancesAsync(new TerminateInstancesRequest{
InstanceIds = new List(){
describeResponse.SpotInstanceRequests[0].InstanceId } });
foreach (InstanceStateChange item in response.TerminatingInstances)
{
Console.WriteLine($"\n Terminated instance: {item.InstanceId}");
Console.WriteLine($" Instance state: {item.CurrentState.Name}\n");
}
}
}
```
## Vollständiger Code
Im folgenden Codebeispiel werden die zuvor beschriebenen Methoden aufgerufen, um eine Spot-Instance-Anfrage zu erstellen und abzubrechen und eine Spot-Instance zu beenden.
### SDK-Referenzen
NuGet Pakete:
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Elemente der Programmierung:
+ [Namespace Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2.html)
Klasse [EC2Amazon-Kunde](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
Klasse [InstanceType](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TInstanceType.html)
+ [Namespace Amazon.EC2.Model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Klasse [CancelSpotInstanceRequestsRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TCancelSpotInstanceRequestsRequest.html)
Klasse [DescribeSpotInstanceRequestsRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeSpotInstanceRequestsRequest.html)
Klasse [DescribeSpotInstanceRequestsResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeSpotInstanceRequestsResponse.html)
Klasse [InstanceStateChange](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TInstanceStateChange.html)
Klasse [LaunchSpecification](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TLaunchSpecification.html)
Klasse [RequestSpotInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TRequestSpotInstancesRequest.html)
Klasse [RequestSpotInstancesResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TRequestSpotInstancesResponse.html)
Klasse [SpotInstanceRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TSpotInstanceRequest.html)
Klasse [TerminateInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TTerminateInstancesRequest.html)
Klasse [TerminateInstancesResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TTerminateInstancesResponse.html)
### Der Code
```
using System;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using Amazon.EC2;
using Amazon.EC2.Model;
namespace EC2SpotInstanceRequests
{
class Program
{
static async Task Main(string[] args)
{
// Some default values.
// These could be made into command-line arguments instead.
var instanceType = InstanceType.T1Micro;
string securityGroupName = "default";
string spotPrice = "0.003";
int instanceCount = 1;
// Parse the command line arguments
if((args.Length != 1) || (!args[0].StartsWith("ami-")))
{
Console.WriteLine("\nUsage: EC2SpotInstanceRequests ami");
Console.WriteLine(" ami: the Amazon Machine Image to use for the Spot Instances.");
return;
}
// Create the Amazon EC2 client.
var ec2Client = new AmazonEC2Client();
// Create the Spot Instance request and record its ID
Console.WriteLine("\nCreating spot instance request...");
var req = await CreateSpotInstanceRequest(
ec2Client, args[0], securityGroupName, instanceType, spotPrice, instanceCount);
string requestId = req.SpotInstanceRequestId;
// Wait for an EC2 Spot Instance to become active
Console.WriteLine(
$"Waiting for Spot Instance request with ID {requestId} to become active...");
int wait = 1;
var start = DateTime.Now;
while(true)
{
Console.Write(".");
// Get and check the status to see if the request has been fulfilled.
var requestInfo = await GetSpotInstanceRequestInfo(ec2Client, requestId);
if(requestInfo.Status.Code == "fulfilled")
{
Console.WriteLine($"\nSpot Instance request {requestId} " +
$"has been fulfilled by instance {requestInfo.InstanceId}.\n");
break;
}
// Wait a bit and try again, longer each time (1, 2, 4, ...)
Thread.Sleep(wait);
wait = wait * 2;
}
// Show the user how long it took to fulfill the Spot Instance request.
TimeSpan span = DateTime.Now.Subtract(start);
Console.WriteLine($"That took {span.TotalMilliseconds} milliseconds");
// Perform actions here as needed.
// For this example, simply wait for the user to hit a key.
// That gives them a chance to look at the EC2 console to see
// the running instance if they want to.
Console.WriteLine("Press any key to start the cleanup...");
Console.ReadKey(true);
// Cancel the request.
// Do this first to make sure that the request can't be re-fulfilled
// once the Spot Instance has been terminated.
Console.WriteLine("Canceling Spot Instance request...");
await CancelSpotInstanceRequest(ec2Client, requestId);
// Terminate the Spot Instance that's running.
Console.WriteLine("Terminating the running Spot Instance...");
await TerminateSpotInstance(ec2Client, requestId);
Console.WriteLine("Done. Press any key to exit...");
Console.ReadKey(true);
}
//
// Method to create a Spot Instance request
private static async Task CreateSpotInstanceRequest(
IAmazonEC2 ec2Client, string amiId, string securityGroupName,
InstanceType instanceType, string spotPrice, int instanceCount)
{
var launchSpecification = new LaunchSpecification{
ImageId = amiId,
InstanceType = instanceType
};
launchSpecification.SecurityGroups.Add(securityGroupName);
var request = new RequestSpotInstancesRequest{
SpotPrice = spotPrice,
InstanceCount = instanceCount,
LaunchSpecification = launchSpecification
};
RequestSpotInstancesResponse result =
await ec2Client.RequestSpotInstancesAsync(request);
return result.SpotInstanceRequests[0];
}
//
// Method to get information about a Spot Instance request, including the status,
// instance ID, etc.
// It gets the information for a specific request (as opposed to all requests).
private static async Task GetSpotInstanceRequestInfo(
IAmazonEC2 ec2Client, string requestId)
{
var describeRequest = new DescribeSpotInstanceRequestsRequest();
describeRequest.SpotInstanceRequestIds.Add(requestId);
DescribeSpotInstanceRequestsResponse describeResponse =
await ec2Client.DescribeSpotInstanceRequestsAsync(describeRequest);
return describeResponse.SpotInstanceRequests[0];
}
//
// Method to cancel a Spot Instance request
private static async Task CancelSpotInstanceRequest(
IAmazonEC2 ec2Client, string requestId)
{
var cancelRequest = new CancelSpotInstanceRequestsRequest();
cancelRequest.SpotInstanceRequestIds.Add(requestId);
await ec2Client.CancelSpotInstanceRequestsAsync(cancelRequest);
}
//
// Method to terminate a Spot Instance
private static async Task TerminateSpotInstance(
IAmazonEC2 ec2Client, string requestId)
{
var describeRequest = new DescribeSpotInstanceRequestsRequest();
describeRequest.SpotInstanceRequestIds.Add(requestId);
// Retrieve the Spot Instance request to check for running instances.
DescribeSpotInstanceRequestsResponse describeResponse =
await ec2Client.DescribeSpotInstanceRequestsAsync(describeRequest);
// If there are any running instances, terminate them
if( (describeResponse.SpotInstanceRequests[0].Status.Code
== "request-canceled-and-instance-running")
|| (describeResponse.SpotInstanceRequests[0].State == SpotInstanceState.Active))
{
TerminateInstancesResponse response =
await ec2Client.TerminateInstancesAsync(new TerminateInstancesRequest{
InstanceIds = new List(){
describeResponse.SpotInstanceRequests[0].InstanceId } });
foreach (InstanceStateChange item in response.TerminatingInstances)
{
Console.WriteLine($"\n Terminated instance: {item.InstanceId}");
Console.WriteLine($" Instance state: {item.CurrentState.Name}\n");
}
}
}
}
}
```
## Weitere Überlegungen
+ Nachdem Sie das Tutorial ausgeführt haben, empfiehlt es sich, sich [bei der Amazon EC2-Konsole](https://console.aws.amazon.com/ec2/) anzumelden, um zu überprüfen, ob die [Spot-Instance-Anfrage](https://console.aws.amazon.com/ec2/home#SpotInstances:) storniert und die [Spot-Instance](https://console.aws.amazon.com/ec2/v2/home#Instances) beendet wurde.
# Zugriff auf AWS Identity and Access Management (IAM) mit dem AWS SDK für .NET
The AWS SDK für .NET [AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/)Supports, ein Webdienst, mit dem AWS Kunden Benutzer und Benutzerberechtigungen verwalten können AWS.
Ein AWS Identity and Access Management (IAM-) *Benutzer* ist eine Entität, in AWS der Sie erstellen. Die Entität stellt eine Person oder Anwendung dar, mit der interagiert. AWS Weitere Informationen zu IAM-Benutzern finden Sie unter [IAM-Benutzer und IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html) [- und STS-Grenzwerte im IAM-Benutzerhandbuch](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-limits.html).
*Sie gewähren einem Benutzer Berechtigungen, indem Sie eine IAM-Richtlinie erstellen.* Die Richtlinie enthält ein *Richtliniendokument*, in dem die Aktionen aufgeführt sind, die ein Benutzer ausführen kann, und die Ressourcen, auf die sich diese Aktionen auswirken können. Weitere Informationen zu IAM-Richtlinien finden Sie unter [Richtlinien und Berechtigungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) im *IAM-Benutzerhandbuch*.
**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).
## APIs
Das AWS SDK für .NET bietet APIs IAM-Clients. Sie APIs ermöglichen es Ihnen, mit IAM-Funktionen wie Benutzern, Rollen und Zugriffsschlüsseln zu arbeiten.
Dieser Abschnitt enthält eine kleine Anzahl von Beispielen, die Ihnen zeigen, welchen Mustern Sie bei der Arbeit mit diesen APIs Modellen folgen können. Den vollständigen Satz von APIs finden Sie in der [AWS SDK für .NET API-Referenz](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/) (und scrollen Sie zu „Amazon. IdentityManagement„).
Dieser Abschnitt enthält auch [ein Beispiel](net-dg-hosm.md), das Ihnen zeigt, wie Sie Amazon EC2 EC2-Instances eine IAM-Rolle zuordnen, um die Verwaltung von Anmeldeinformationen zu vereinfachen.
[Die IAM APIs werden bereitgestellt von. AWSSDK IdentityManagement](https://www.nuget.org/packages/AWSSDK.IdentityManagement) NuGetPaket.
## Voraussetzungen
Bevor Sie beginnen, stellen Sie sicher, dass Sie [Ihre Umgebung und Ihr Projekt eingerichtet](net-dg-config.md) haben. Lesen Sie auch die Informationen unter[SDK-Funktionen](net-dg-sdk-features.md).
## Topics
**Topics**
+ [APIs](#w2aac19c15c19c13)
+ [Voraussetzungen](#w2aac19c15c19c15)
+ [Topics](#w2aac19c15c19c17)
+ [Verwaltete Richtlinien aus JSON erstellen](iam-policies-create-json.md)
+ [Richtliniendokumente anzeigen](iam-policies-display.md)
+ [Zugriff mit einer Rolle gewähren](net-dg-hosm.md)
# Von IAM verwaltete Richtlinien aus JSON erstellen
Dieses Beispiel zeigt Ihnen, wie Sie mithilfe von eine [IAM-verwaltete Richtlinie aus einem bestimmten Richtliniendokument](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) in JSON erstellen können. AWS SDK für .NET Die Anwendung erstellt ein IAM-Client-Objekt, liest das Richtliniendokument aus einer Datei und erstellt dann die Richtlinie.
**Anmerkung**
Ein Beispiel für ein Richtliniendokument in JSON finden Sie in den [zusätzlichen Überlegungen](#iam-policies-create-json-additional) am Ende dieses Themas.
Die folgenden Abschnitte enthalten Auszüge aus diesem Beispiel. Der [vollständige Code für das Beispiel](#iam-policies-create-json-complete-code) wird danach angezeigt und kann unverändert erstellt und ausgeführt werden.
**Topics**
+ [Erstellen der -Richtlinie](#iam-policies-create-json-create)
+ [Vollständiger Code](#iam-policies-create-json-complete-code)
+ [Weitere Überlegungen](#iam-policies-create-json-additional)
## Erstellen der -Richtlinie
Das folgende Snippet erstellt eine von IAM verwaltete Richtlinie mit dem angegebenen Namen und dem Richtliniendokument.
Das Beispiel [am Ende dieses Themas zeigt, wie dieser](#iam-policies-create-json-complete-code) Codeausschnitt verwendet wird.
```
//
// Method to create an IAM policy from a JSON file
private static async Task CreateManagedPolicy(
IAmazonIdentityManagementService iamClient, string policyName, string jsonFilename)
{
return await iamClient.CreatePolicyAsync(new CreatePolicyRequest{
PolicyName = policyName,
PolicyDocument = File.ReadAllText(jsonFilename)});
}
```
## Vollständiger Code
Dieser Abschnitt enthält relevante Referenzen und den vollständigen Code für dieses Beispiel.
### SDK-Referenzen
NuGet Pakete:
+ [AWSSDK.IdentityManagement](https://www.nuget.org/packages/AWSSDK.IdentityManagement)
Elemente der Programmierung:
+ Namespace [Amazon. IdentityManagement](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IAM/NIAM.html)
Klasse [AmazonIdentityManagementServiceClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IAM/TIAMServiceClient.html)
+ Namespace [Amazon. IdentityManagement.Modell](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IAM/NIAMModel.html)
Klasse [CreatePolicyRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IAM/TCreatePolicyRequest.html)
Klasse [CreatePolicyResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IAM/TCreatePolicyResponse.html)
### Der Code
```
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Amazon.IdentityManagement;
using Amazon.IdentityManagement.Model;
namespace IamCreatePolicyFromJson
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to create an IAM policy with a given policy document
class Program
{
private const int MaxArgs = 2;
static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if((parsedArgs.Count == 0) || (parsedArgs.Count > MaxArgs))
{
PrintHelp();
return;
}
// Get the application arguments from the parsed list
string policyName =
CommandLine.GetArgument(parsedArgs, null, "-p", "--policy-name");
string policyFilename =
CommandLine.GetArgument(parsedArgs, null, "-j", "--json-filename");
if( string.IsNullOrEmpty(policyName)
|| (string.IsNullOrEmpty(policyFilename) || !policyFilename.EndsWith(".json")))
CommandLine.ErrorExit(
"\nOne or more of the required arguments is missing or incorrect." +
"\nRun the command with no arguments to see help.");
// Create an IAM service client
var iamClient = new AmazonIdentityManagementServiceClient();
// Create the new policy
var response = await CreateManagedPolicy(iamClient, policyName, policyFilename);
Console.WriteLine($"\nPolicy {response.Policy.PolicyName} has been created.");
Console.WriteLine($" Arn: {response.Policy.Arn}");
}
//
// Method to create an IAM policy from a JSON file
private static async Task CreateManagedPolicy(
IAmazonIdentityManagementService iamClient, string policyName, string jsonFilename)
{
return await iamClient.CreatePolicyAsync(new CreatePolicyRequest{
PolicyName = policyName,
PolicyDocument = File.ReadAllText(jsonFilename)});
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine(
"\nUsage: IamCreatePolicyFromJson -p -j " +
"\n -p, --policy-name: The name you want the new policy to have." +
"\n -j, --json-filename: The name of the JSON file with the policy document.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
## Weitere Überlegungen
+ Im Folgenden finden Sie ein Beispiel für ein Richtliniendokument, das Sie in eine JSON-Datei kopieren und als Eingabe für diese Anwendung verwenden können:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id" : "DotnetTutorialPolicy",
"Statement" : [
{
"Sid" : "DotnetTutorialPolicyS3",
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : "*"
},
{
"Sid" : "DotnetTutorialPolicyPolly",
"Effect": "Allow",
"Action": [
"polly:DescribeVoices",
"polly:SynthesizeSpeech"
],
"Resource": "*"
}
]
}
```
------
+ Sie können in der [IAM-Konsole](https://console.aws.amazon.com/iam/home#/policies) überprüfen, ob die Richtlinie erstellt wurde. Wählen Sie in der Dropdownliste **Filterrichtlinien die** Option Vom **Kunden verwaltet** aus. Löschen Sie die Richtlinie, wenn Sie sie nicht mehr benötigen.
+ Weitere Informationen zur Erstellung von Richtlinien finden Sie unter [Erstellen von IAM-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) und in der [IAM-JSON-Richtlinienreferenz](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html) im [IAM-Benutzerhandbuch](https://docs.aws.amazon.com/IAM/latest/UserGuide/)
# Zeigen Sie das Richtliniendokument einer von IAM verwalteten Richtlinie an
Dieses Beispiel zeigt Ihnen, wie Sie mit AWS SDK für .NET dem ein Richtliniendokument anzeigen können. Die Anwendung erstellt ein IAM-Client-Objekt, sucht die Standardversion der angegebenen IAM-verwalteten Richtlinie und zeigt dann das Richtliniendokument in JSON an.
Die folgenden Abschnitte enthalten Auszüge aus diesem Beispiel. Der [vollständige Code für das Beispiel](#iam-policies-display-complete-code) wird danach angezeigt und kann unverändert erstellt und ausgeführt werden.
**Topics**
+ [Finden Sie die Standardversion](#iam-policies-display-version)
+ [Zeigen Sie das Richtliniendokument an](#iam-policies-display-doc)
+ [Vollständiger Code](#iam-policies-display-complete-code)
## Finden Sie die Standardversion
Das folgende Snippet findet die Standardversion der angegebenen IAM-Richtlinie.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#iam-policies-display-complete-code) Snippet verwendet wird.
```
//
// Method to determine the default version of an IAM policy
// Returns a string with the version
private static async Task GetDefaultVersion(
IAmazonIdentityManagementService iamClient, string policyArn)
{
// Retrieve all the versions of this policy
string defaultVersion = string.Empty;
ListPolicyVersionsResponse reponseVersions =
await iamClient.ListPolicyVersionsAsync(new ListPolicyVersionsRequest{
PolicyArn = policyArn});
// Find the default version
foreach(PolicyVersion version in reponseVersions.Versions)
{
if(version.IsDefaultVersion)
{
defaultVersion = version.VersionId;
break;
}
}
return defaultVersion;
}
```
## Zeigen Sie das Richtliniendokument an
Der folgende Ausschnitt zeigt das Richtliniendokument der angegebenen IAM-Richtlinie in JSON an.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#iam-policies-display-complete-code) Snippet verwendet wird.
```
//
// Method to retrieve and display the policy document of an IAM policy
private static async Task ShowPolicyDocument(
IAmazonIdentityManagementService iamClient, string policyArn, string defaultVersion)
{
// Retrieve the policy document of the default version
GetPolicyVersionResponse responsePolicy =
await iamClient.GetPolicyVersionAsync(new GetPolicyVersionRequest{
PolicyArn = policyArn,
VersionId = defaultVersion});
// Display the policy document (in JSON)
Console.WriteLine($"Version {defaultVersion} of the policy (in JSON format):");
Console.WriteLine(
$"{HttpUtility.UrlDecode(responsePolicy.PolicyVersion.Document)}");
}
```
## Vollständiger Code
Dieser Abschnitt enthält relevante Referenzen und den vollständigen Code für dieses Beispiel.
### SDK-Referenzen
NuGet Pakete:
+ [AWSSDK.IdentityManagement](https://www.nuget.org/packages/AWSSDK.IdentityManagement)
Elemente der Programmierung:
+ Namespace [Amazon. IdentityManagement](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IAM/NIAM.html)
Klasse [AmazonIdentityManagementServiceClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IAM/TIAMServiceClient.html)
+ Namespace [Amazon. IdentityManagement.Modell](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IAM/NIAMModel.html)
Klasse [GetPolicyVersionRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IAM/TGetPolicyVersionRequest.html)
Klasse [GetPolicyVersionResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IAM/TGetPolicyVersionResponse.html)
Klasse [ListPolicyVersionsRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IAM/TListPolicyVersionsRequest.html)
Klasse [ListPolicyVersionsResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IAM/TListPolicyVersionsResponse.html)
Klasse [PolicyVersion](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IAM/TPolicyVersion.html)
### Der Code
```
using System;
using System.Web;
using System.Threading.Tasks;
using Amazon.IdentityManagement;
using Amazon.IdentityManagement.Model;
namespace IamDisplayPolicyJson
{
class Program
{
static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
if(args.Length != 1)
{
Console.WriteLine("\nUsage: IamDisplayPolicyJson policy-arn");
Console.WriteLine(" policy-arn: The ARN of the policy to retrieve.");
return;
}
if(!args[0].StartsWith("arn:"))
{
Console.WriteLine("\nCould not find policy ARN in the command-line arguments:");
Console.WriteLine($"{args[0]}");
return;
}
// Create an IAM service client
var iamClient = new AmazonIdentityManagementServiceClient();
// Retrieve and display the policy document of the given policy
string defaultVersion = await GetDefaultVersion(iamClient, args[0]);
if(string.IsNullOrEmpty(defaultVersion))
Console.WriteLine($"Could not find the default version for policy {args[0]}.");
else
await ShowPolicyDocument(iamClient, args[0], defaultVersion);
}
//
// Method to determine the default version of an IAM policy
// Returns a string with the version
private static async Task GetDefaultVersion(
IAmazonIdentityManagementService iamClient, string policyArn)
{
// Retrieve all the versions of this policy
string defaultVersion = string.Empty;
ListPolicyVersionsResponse reponseVersions =
await iamClient.ListPolicyVersionsAsync(new ListPolicyVersionsRequest{
PolicyArn = policyArn});
// Find the default version
foreach(PolicyVersion version in reponseVersions.Versions)
{
if(version.IsDefaultVersion)
{
defaultVersion = version.VersionId;
break;
}
}
return defaultVersion;
}
//
// Method to retrieve and display the policy document of an IAM policy
private static async Task ShowPolicyDocument(
IAmazonIdentityManagementService iamClient, string policyArn, string defaultVersion)
{
// Retrieve the policy document of the default version
GetPolicyVersionResponse responsePolicy =
await iamClient.GetPolicyVersionAsync(new GetPolicyVersionRequest{
PolicyArn = policyArn,
VersionId = defaultVersion});
// Display the policy document (in JSON)
Console.WriteLine($"Version {defaultVersion} of the policy (in JSON format):");
Console.WriteLine(
$"{HttpUtility.UrlDecode(responsePolicy.PolicyVersion.Document)}");
}
}
}
```
# Zugriff mithilfe einer IAM-Rolle gewähren
Dieses Tutorial zeigt Ihnen, wie Sie die verwenden, um IAM-Rollen auf Amazon EC2 EC2-Instances AWS SDK für .NET zu aktivieren.
## -Übersicht
Alle Anfragen an AWS müssen mit den von ausgestellten Anmeldeinformationen kryptografisch signiert werden. AWS Daher benötigen Sie eine Strategie zur Verwaltung von Anmeldeinformationen für Anwendungen, die auf Amazon EC2 EC2-Instances ausgeführt werden. Sie müssen diese Anmeldeinformationen sicher verteilen, speichern und rotieren, aber auch dafür sorgen, dass sie für die Anwendungen zugänglich sind.
Mit IAM-Rollen können Sie diese Anmeldeinformationen effektiv verwalten. Sie erstellen eine IAM-Rolle und konfigurieren sie mit den Berechtigungen, die eine Anwendung benötigt, und fügen diese Rolle dann einer EC2-Instance hinzu. Weitere Informationen zu den Vorteilen der Verwendung von IAM-Rollen finden Sie unter [IAM-Rollen für Amazon EC2 im Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) [EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/). Lesen Sie auch die Informationen zu [IAM-Rollen im IAM-Benutzerhandbuch](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).
Bei einer Anwendung, die mit dem erstellt wurde AWS SDK für .NET, sucht das Objekt, wenn die Anwendung ein Client-Objekt für einen AWS Dienst erstellt, nach Anmeldeinformationen aus verschiedenen möglichen Quellen. Die Reihenfolge, in der gesucht wird, wird in [Auflösung von Anmeldeinformationen und Profilen](creds-assign.md) angezeigt.
Wenn das Client-Objekt keine Anmeldeinformationen aus einer anderen Quelle findet, ruft es temporäre Anmeldeinformationen ab, die dieselben Berechtigungen haben wie diejenigen, die für die IAM-Rolle konfiguriert wurden und sich in den Metadaten der EC2-Instance befinden. Diese Anmeldeinformationen werden verwendet, um vom Client-Objekt AWS aus Aufrufe zu tätigen.
## Über dieses Tutorial
Während Sie diesem Tutorial folgen, verwenden Sie die AWS SDK für .NET (und andere Tools), um eine Amazon EC2 EC2-Instance mit einer angehängten IAM-Rolle zu starten und sehen dann eine Anwendung auf der Instance, die die Berechtigungen der IAM-Rolle verwendet.
**Topics**
+ [-Übersicht](#hosm-overview)
+ [Über dieses Tutorial](#about-hosm-tutorial)
+ [Erstellen Sie eine Amazon S3 S3-Beispielanwendung](#net-dg-hosm-sample-s3-app)
+ [Erstellen einer IAM-Rolle](#net-dg-hosm-create-the-role)
+ [Starten Sie eine EC2-Instance und fügen Sie die IAM-Rolle hinzu](#net-dg-hosm-launch-ec2-instance)
+ [Connect zur EC2-Instance her](#net-dg-hosm-connect)
+ [Führen Sie die Beispielanwendung auf der EC2-Instance aus](#net-dg-hosm-run-the-app)
+ [Bereinigen](#net-dg-hosm-cleanup)
## Erstellen Sie eine Amazon S3 S3-Beispielanwendung
Diese Beispielanwendung ruft ein Objekt von Amazon S3 ab. Um die Anwendung auszuführen, benötigen Sie Folgendes:
+ Ein Amazon S3 S3-Bucket, der eine Textdatei enthält.
+ AWS Anmeldeinformationen auf Ihrem Entwicklungscomputer, die Ihnen den Zugriff auf den Bucket ermöglichen.
Informationen zum Erstellen eines Amazon S3 S3-Buckets und zum Hochladen eines Objekts finden Sie im [Amazon Simple Storage Service-Benutzerhandbuch](https://docs.aws.amazon.com/AmazonS3/latest/userguide/). Informationen zu AWS Anmeldeinformationen finden Sie unter[Konfigurieren Sie die SDK-Authentifizierung mit AWS](creds-idc.md).
Erstellen Sie ein .NET Core-Projekt mit dem folgenden Code. Testen Sie dann die Anwendung auf Ihrem Entwicklungscomputer.
**Anmerkung**
Auf Ihrem Entwicklungscomputer ist die.NET Core Runtime installiert, sodass Sie die Anwendung ausführen können, ohne sie zu veröffentlichen. Wenn Sie später in diesem Tutorial eine EC2-Instanz erstellen, können Sie sich dafür entscheiden, die .NET Core Runtime auf der Instanz zu installieren. Dies bietet Ihnen eine ähnliche Erfahrung und eine geringere Dateiübertragung.
Sie können sich jedoch auch dafür entscheiden, die.NET Core Runtime nicht auf der Instanz zu installieren. Wenn Sie sich für diese Vorgehensweise entscheiden, müssen Sie die Anwendung veröffentlichen, sodass bei der Übertragung auf die Instanz alle Abhängigkeiten berücksichtigt werden.
### SDK-Referenzen
NuGet Pakete:
+ [AWSSDK.S3](https://www.nuget.org/packages/AWSSDK.S3)
Elemente der Programmierung:
+ [Namespace Amazon.S3](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/S3/NS3.html)
Klasse [AmazonS3Client](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/S3/TS3Client.html)
+ Namespace [Amazon.S3.Model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/S3/NS3Model.html)
Klasse [GetObjectResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/S3/TGetObjectResponse.html)
### Der Code
```
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Amazon.S3;
using Amazon.S3.Model;
namespace S3GetTextItem
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to retrieve a text file from an S3 bucket and write it to a local file
class Program
{
static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if(parsedArgs.Count == 0)
{
PrintHelp();
return;
}
// Get the application arguments from the parsed list
string bucket =
CommandLine.GetArgument(parsedArgs, null, "-b", "--bucket-name");
string item =
CommandLine.GetArgument(parsedArgs, null, "-t", "--text-object");
string outFile =
CommandLine.GetArgument(parsedArgs, null, "-o", "--output-filename");
if( string.IsNullOrEmpty(bucket)
|| string.IsNullOrEmpty(item)
|| string.IsNullOrEmpty(outFile))
CommandLine.ErrorExit(
"\nOne or more of the required arguments is missing or incorrect." +
"\nRun the command with no arguments to see help.");
// Create the S3 client object and get the file object from the bucket.
var response = await GetObject(new AmazonS3Client(), bucket, item);
// Write the contents of the file object to the given output file.
var reader = new StreamReader(response.ResponseStream);
string contents = reader.ReadToEnd();
using (var s = new FileStream(outFile, FileMode.Create))
using (var writer = new StreamWriter(s))
writer.WriteLine(contents);
}
//
// Method to get an object from an S3 bucket.
private static async Task GetObject(
IAmazonS3 s3Client, string bucket, string item)
{
Console.WriteLine($"Retrieving {item} from bucket {bucket}.");
return await s3Client.GetObjectAsync(bucket, item);
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine(
"\nUsage: S3GetTextItem -b -t -o " +
"\n -b, --bucket-name: The name of the S3 bucket." +
"\n -t, --text-object: The name of the text object in the bucket." +
"\n -o, --output-filename: The name of the file to write the text to.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
Wenn Sie möchten, können Sie die Anmeldeinformationen, die Sie auf Ihrem Entwicklungscomputer verwenden, vorübergehend entfernen, um zu sehen, wie die Anwendung reagiert. (Stellen Sie jedoch sicher, dass Sie die Anmeldeinformationen wiederherstellen, wenn Sie fertig sind.)
## Erstellen einer IAM-Rolle
Erstellen Sie eine IAM-Rolle, die über die entsprechenden Berechtigungen für den Zugriff auf Amazon S3 verfügt.
1. Öffnen Sie die [IAM-Konsole](https://console.aws.amazon.com/iam/).
1. Wählen Sie im Navigationsbereich **Rollen** und dann **Rolle erstellen** aus.
1. Wählen Sie **AWS Service** aus, suchen und wählen Sie **EC2** und klicken Sie dann auf **Weiter: Berechtigungen**.
1. Suchen **Sie unter Richtlinien zum Anhängen von Berechtigungen** nach **ReadOnlyAccessAmazonS3** und wählen Sie es aus. Überprüfen Sie die Richtlinie, falls Sie möchten, und wählen Sie dann **Weiter: Tags** aus.
1. Fügen Sie Schlagworte hinzu, wenn Sie möchten, und wählen Sie dann **Weiter: Überprüfen**.
1. Geben Sie einen Namen und eine Beschreibung für die Rolle ein und wählen Sie dann **Create role** aus. Notieren Sie sich diesen Namen, da Sie ihn benötigen, wenn Sie die EC2-Instance starten.
## Starten Sie eine EC2-Instance und fügen Sie die IAM-Rolle hinzu
Starten Sie eine EC2-Instance mit der IAM-Rolle, die Sie zuvor erstellt haben. Sie können dies auf folgende Weise tun.
+ **Verwenden der EC2-Konsole**
Informationen zum Starten einer Instance mithilfe der EC2-Konsole finden Sie unter [Starten einer Instance mithilfe des Assistenten zum Starten einer Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-instance-wizard.html) im [Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
Wenn Sie sich die Startseite ansehen, sollten Sie zumindest den Bereich mit den **erweiterten Details** erweitern, sodass Sie die IAM-Rolle angeben können, die Sie zuvor im **IAM-Instance-Profil** erstellt haben.
+ **Verwenden Sie den AWS SDK für .NET**
Informationen dazu finden Sie unter[Starten einer Amazon EC2 EC2-Instance](run-instance.md), auch [Weitere Überlegungen](run-instance.md#run-instance-additional) am Ende dieses Themas.
Um eine EC2-Instance zu starten, der eine IAM-Rolle zugewiesen ist, muss die Konfiguration eines IAM-Benutzers bestimmte Berechtigungen enthalten. Weitere Informationen zu den erforderlichen [Berechtigungen finden Sie unter Erteilen einer Benutzerberechtigung zur Übergabe einer IAM-Rolle an eine Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#permission-to-pass-iam-roles) im [Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
## Connect zur EC2-Instance her
Stellen Sie eine Verbindung mit der EC2-Instance her, sodass Sie die Beispielanwendung auf diese übertragen und dann die Anwendung ausführen können. Sie benötigen die Datei, die den privaten Teil des key pair enthält, das Sie zum Starten der Instance verwendet haben, d. h. die PEM-Datei.
Informationen zum Herstellen einer Verbindung mit einer Instance finden [Sie unter Connect to your Linux Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html) oder [Connect to your Windows Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/connecting_to_windows_instance.html) im [Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/). Wenn Sie eine Verbindung herstellen, tun Sie dies so, dass Sie Dateien von Ihrem Entwicklungscomputer auf Ihre Instance übertragen können.
Wenn Sie Visual Studio unter Windows verwenden, können Sie auch mithilfe des Toolkit for Visual Studio eine Verbindung mit der Instanz herstellen. Weitere Informationen finden Sie unter [Herstellen einer Verbindung zu einer Amazon EC2 EC2-Instance](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/tkv-ec2-ami.html#connect-ec2) im AWS Toolkit for Visual Studio Benutzerhandbuch.
## Führen Sie die Beispielanwendung auf der EC2-Instance aus
1. Kopieren Sie die Anwendungsdateien von Ihrem lokalen Laufwerk auf Ihre Instance.
Welche Dateien Sie übertragen, hängt davon ab, wie Sie die Anwendung erstellt haben und ob auf Ihrer Instanz die.NET Core Runtime installiert ist. Informationen zum Übertragen von Dateien auf Ihre Instance finden Sie unter [Connect zu Ihrer Linux-Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html) herstellen (siehe den entsprechenden Unterabschnitt) oder [Dateien auf Windows-Instances übertragen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instanceWindowsFileTransfer.html) im [Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
1. Starten Sie die Anwendung und stellen Sie sicher, dass sie mit den gleichen Ergebnissen wie auf Ihrem Entwicklungscomputer ausgeführt wird.
1. Stellen Sie sicher, dass die Anwendung die von der IAM-Rolle bereitgestellten Anmeldeinformationen verwendet.
1. Öffnen Sie die [Amazon EC2-Konsole](https://console.aws.amazon.com/ec2/).
1. Wählen Sie die Instanz aus und trennen Sie die IAM-Rolle über **Aktionen**, **Instanzeinstellungen**, IAM-Rolle **anfügen/ersetzen**.
1. Führen Sie die Anwendung erneut aus und stellen Sie fest, dass sie einen Autorisierungsfehler zurückgibt.
## Bereinigen
Wenn Sie mit diesem Tutorial fertig sind und die von Ihnen erstellte EC2-Instance nicht mehr benötigen, sollten Sie die Instance unbedingt beenden, um unerwünschte Kosten zu vermeiden. Sie können dies in der [Amazon EC2 EC2-Konsole](https://console.aws.amazon.com/ec2/) oder programmgesteuert tun, wie unter beschrieben. [Beenden einer Amazon EC2 EC2-Instance](terminate-instance.md) Wenn Sie möchten, können Sie auch andere Ressourcen löschen, die Sie für dieses Tutorial erstellt haben. Dazu können eine IAM-Rolle, ein EC2-Schlüsselpaar und eine PEM-Datei, eine Sicherheitsgruppe usw. gehören.
# Verwenden des Internetspeichers von Amazon Simple Storage Service
Das AWS SDK für .NET unterstützt [Amazon S3](https://aws.amazon.com/s3/), einen Speicher für das Internet. Der Service ist darauf ausgelegt, Cloud Computing für Entwickler zu erleichtern.
## APIs
Das AWS SDK für .NET bietet APIs Amazon S3 S3-Clients. Sie APIs ermöglichen es Ihnen, mit Amazon S3 S3-Ressourcen wie Buckets und Artikeln zu arbeiten. Den vollständigen Satz von APIs für Amazon S3 finden Sie im Folgenden:
+ [AWS SDK für .NET API-Referenz](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/) (und scrollen Sie zu „Amazon.S3").
+ [Amazon.Extensions.S3.Dokumentation](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.html) zur Verschlüsselung
Die Amazon S3 APIs werden in den folgenden NuGet Paketen bereitgestellt:
+ [AWSSDKS3](https://www.nuget.org/packages/AWSSDK.S3)
+ [Amazon.Extensions.S3. Verschlüsselung](https://www.nuget.org/packages/Amazon.Extensions.S3.Encryption)
## Voraussetzungen
Bevor Sie beginnen, stellen Sie sicher, dass Sie Ihre Umgebung und Ihr Projekt [eingerichtet](net-dg-config.md) haben. Lesen Sie auch die Informationen unter[SDK-Funktionen](net-dg-sdk-features.md).
## Beispiele in diesem Dokument
Die folgenden Themen in diesem Dokument zeigen Ihnen, wie Sie den verwenden AWS SDK für .NET , um mit Amazon S3 zu arbeiten.
+ [Verwendung von KMS-Schlüsseln für die S3-Verschlüsselung](kms-keys-s3-encryption.md)
## Beispiele in anderen Dokumenten
Die folgenden Links zum [Amazon S3-Entwicklerhandbuch](https://docs.aws.amazon.com/AmazonS3/latest/userguide/) enthalten zusätzliche Beispiele für die Verwendung von für AWS SDK für .NET die Arbeit mit Amazon S3.
**Anmerkung**
Diese Beispiele und zusätzliche Überlegungen zur Programmierung wurden zwar für Version 3 AWS SDK für .NET des.NET-Frameworks entwickelt, sie eignen sich aber auch für spätere Versionen AWS SDK für .NET des.NET Core. Manchmal sind kleine Anpassungen im Code erforderlich.
**Amazon S3 S3-Programmierbeispiele**
+ [Verwaltung ACLs](https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-using-dot-net-sdk.html)
+ [Erstellen eines Buckets](https://docs.aws.amazon.com/AmazonS3/latest/dev/create-bucket-get-location-example.html#create-bucket-get-location-dotnet)
+ [Hochladen eines Objekts](https://docs.aws.amazon.com/AmazonS3/latest/dev/UploadObjSingleOpNET.html)
+ [Mehrteiliger Upload mit der High-Level-API ([Amazon.S3.Transfer. TransferUtility](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/S3/TTransferUtility.html))](https://docs.aws.amazon.com/AmazonS3/latest/dev/usingHLmpuDotNet.html)
+ [Mehrteilige Uploads mit der Low-Level-API](https://docs.aws.amazon.com/AmazonS3/latest/dev/usingLLmpuDotNet.html)
+ [Auflisten von Objekten](https://docs.aws.amazon.com/AmazonS3/latest/dev/list-obj-version-enabled-bucket.html#list-obj-version-enabled-bucket-sdk-examples)
+ [Auflisten von Schlüsseln](https://docs.aws.amazon.com/AmazonS3/latest/dev/ListingObjectKeysUsingNetSDK.html)
+ [Abrufen eines Objekts](https://docs.aws.amazon.com/AmazonS3/latest/dev/RetrievingObjectUsingNetSDK.html)
+ [Kopieren eines Objekts](https://docs.aws.amazon.com/AmazonS3/latest/dev/CopyingObjectUsingNetSDK.html)
+ [Kopieren eines Objekts unter Verwendung der API für mehrteilige Uploads](https://docs.aws.amazon.com/AmazonS3/latest/dev/CopyingObjctsUsingLLNetMPUapi.html)
+ [Löschen eines Objekts](https://docs.aws.amazon.com/AmazonS3/latest/dev/DeletingOneObjectUsingNetSDK.html)
+ [Löschen von mehreren Objekten](https://docs.aws.amazon.com/AmazonS3/latest/dev/DeletingMultipleObjectsUsingNetSDK.html)
+ [Wiederherstellen eines Objekts](https://docs.aws.amazon.com/AmazonS3/latest/dev/restore-object-dotnet.html)
+ [Konfigurieren eines Buckets für Benachrichtigungen](https://docs.aws.amazon.com/AmazonS3/latest/dev/ways-to-add-notification-config-to-bucket.html)
+ [Verwalten des Lebenszyklus eines Objekts](https://docs.aws.amazon.com/AmazonS3/latest/dev/manage-lifecycle-using-dot-net.html)
+ [Generieren einer vorsignierten Objekt-URL](https://docs.aws.amazon.com/AmazonS3/latest/dev/ShareObjectPreSignedURLDotNetSDK.html)
+ [Verwalten von Websites](https://docs.aws.amazon.com/AmazonS3/latest/dev/ConfigWebSiteDotNet.html)
+ [Cross-Origin Resource Sharing (CORS) aktivieren](https://docs.aws.amazon.com/AmazonS3/latest/dev/ManageCorsUsingDotNet.html)
**Zusätzliche Überlegungen zur Programmierung**
+ [Verwenden der AWS SDK für .NET für Amazon S3 S3-Programmierung](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingTheMPDotNetAPI.html)
+ [Erstellen von Anfragen unter Verwendung temporärer Anmeldeinformationen für IAM-Benutzer](https://docs.aws.amazon.com/AmazonS3/latest/dev/AuthUsingTempSessionTokenDotNet.html)
+ [Anfragen unter Verwendung temporärer Anmeldeinformationen verbundener Benutzer stellen](https://docs.aws.amazon.com/AmazonS3/latest/dev/AuthUsingTempFederationTokenDotNet.html)
+ [Festlegen einer serverseitigen Verschlüsselung](https://docs.aws.amazon.com/AmazonS3/latest/dev/SSEUsingDotNetSDK.html)
+ [Festlegen einer serverseitigen Verschlüsselung mit vom Kunden bereitgestellten Verschlüsselungsschlüsseln](https://docs.aws.amazon.com/AmazonS3/latest/dev/sse-c-using-dot-net-sdk.html)
# Verwendung von AWS KMS Schlüsseln für die Amazon S3 S3-Verschlüsselung in der AWS SDK für .NET
Dieses Beispiel zeigt Ihnen, wie Sie AWS Key Management Service Schlüssel verwenden, um Amazon S3 S3-Objekte zu verschlüsseln. Die Anwendung erstellt einen Kundenhauptschlüssel (CMK) und verwendet ihn, um ein [AmazonS3 EncryptionClient V2-Objekt für die clientseitige Verschlüsselung](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.AmazonS3EncryptionClientV2.html) zu erstellen. Die Anwendung verwendet diesen Client, um ein verschlüsseltes Objekt aus einer bestimmten Textdatei in einem vorhandenen Amazon S3 S3-Bucket zu erstellen. Anschließend entschlüsselt sie das Objekt und zeigt seinen Inhalt an.
**Warnung**
Eine ähnliche Klasse namens `AmazonS3EncryptionClient` ist veraltet und weniger sicher als die Klasse. `AmazonS3EncryptionClientV2` Informationen zur Migration von vorhandenem Code, der verwendet`AmazonS3EncryptionClient`, finden Sie unter. [Migration des S3-Verschlüsselungsclients (V1 auf V2)](s3-encryption-migration-v1-v2.md)
**Topics**
+ [Verschlüsselungsmaterial erstellen](#kms-s3-enc-mat)
+ [Ein Amazon S3 S3-Objekt erstellen und verschlüsseln](#kms-s3-create-ojbect)
+ [Vollständiger Code](#kms-s3-complete-code)
+ [Weitere Überlegungen](#kms-s3-additional)
## Verschlüsselungsmaterial erstellen
Mit dem folgenden Codeausschnitt wird ein `EncryptionMaterials` Objekt erstellt, das eine KMS-Schlüssel-ID enthält.
Das Beispiel [am Ende dieses Themas zeigt, wie dieser](#kms-s3-complete-code) Codeausschnitt verwendet wird.
```
// Create a customer master key (CMK) and store the result
CreateKeyResponse createKeyResponse =
await new AmazonKeyManagementServiceClient().CreateKeyAsync(new CreateKeyRequest());
var kmsEncryptionContext = new Dictionary();
var kmsEncryptionMaterials = new EncryptionMaterialsV2(
createKeyResponse.KeyMetadata.KeyId, KmsType.KmsContext, kmsEncryptionContext);
```
## Ein Amazon S3 S3-Objekt erstellen und verschlüsseln
Der folgende Ausschnitt erstellt ein `AmazonS3EncryptionClientV2` Objekt, das die zuvor erstellten Verschlüsselungsmaterialien verwendet. Anschließend verwendet es den Client, um ein neues Amazon S3 S3-Objekt zu erstellen und zu verschlüsseln.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#kms-s3-complete-code) Snippet verwendet wird.
```
//
// Method to create and encrypt an object in an S3 bucket
static async Task CreateAndRetrieveObjectAsync(
EncryptionMaterialsV2 materials, string bucketName,
string fileName, string itemName)
{
// CryptoStorageMode.ObjectMetadata is required for KMS EncryptionMaterials
var config = new AmazonS3CryptoConfigurationV2(SecurityProfile.V2AndLegacy)
{
StorageMode = CryptoStorageMode.ObjectMetadata
};
var s3EncClient = new AmazonS3EncryptionClientV2(config, materials);
// Create, encrypt, and put the object
await s3EncClient.PutObjectAsync(new PutObjectRequest
{
BucketName = bucketName,
Key = itemName,
ContentBody = File.ReadAllText(fileName)
});
// Get, decrypt, and return the object
return await s3EncClient.GetObjectAsync(new GetObjectRequest
{
BucketName = bucketName,
Key = itemName
});
}
```
## Vollständiger Code
Dieser Abschnitt enthält relevante Referenzen und den vollständigen Code für dieses Beispiel.
### SDK-Referenzen
NuGet Pakete:
+ [Amazon.Extensions.S3. Verschlüsselung](https://www.nuget.org/packages/Amazon.Extensions.S3.Encryption)
Elemente der Programmierung:
+ [Namespace Amazon.Extensions.S3.Verschlüsselung](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.html)
Klasse [AmazonS3 V2 EncryptionClient](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.AmazonS3EncryptionClientV2.html)
[Klasse AmazonS3 V2 CryptoConfiguration](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.AmazonS3CryptoConfigurationV2.html)
Klasse [CryptoStorageMode](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.CryptoStorageMode.html)
Klasse [EncryptionMaterialsV2](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.EncryptionMaterialsV2.html)
+ [Namespace Amazon.Extensions.S3.Encryption.Primitives](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.Primitives.html)
Klasse [KmsType](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.Primitives.KmsType.html)
+ [Namespace Amazon.S3.Model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/S3/NS3Model.html)
Klasse [GetObjectRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/S3/TGetObjectRequest.html)
Klasse [GetObjectResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/S3/TGetObjectResponse.html)
Klasse [PutObjectRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/S3/TPutObjectRequest.html)
+ Namespace [Amazon. KeyManagementService](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/KeyManagementService/NKeyManagementService.html)
Klasse [AmazonKeyManagementServiceClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/KeyManagementService/TKeyManagementServiceClient.html)
+ Namespace [Amazon. KeyManagementService.Modell](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/KeyManagementService/NKeyManagementServiceModel.html)
Klasse [CreateKeyRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/KeyManagementService/TCreateKeyRequest.html)
Klasse [CreateKeyResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/KeyManagementService/TCreateKeyResponse.html)
### Der Code
```
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Amazon.Extensions.S3.Encryption;
using Amazon.Extensions.S3.Encryption.Primitives;
using Amazon.S3.Model;
using Amazon.KeyManagementService;
using Amazon.KeyManagementService.Model;
namespace KmsS3Encryption
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to store text in an encrypted S3 object.
class Program
{
private const int MaxArgs = 3;
public static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if((parsedArgs.Count == 0) || (parsedArgs.Count > MaxArgs))
{
PrintHelp();
return;
}
// Get the application arguments from the parsed list
string bucketName =
CommandLine.GetArgument(parsedArgs, null, "-b", "--bucket-name");
string fileName =
CommandLine.GetArgument(parsedArgs, null, "-f", "--file-name");
string itemName =
CommandLine.GetArgument(parsedArgs, null, "-i", "--item-name");
if(string.IsNullOrEmpty(bucketName) || (string.IsNullOrEmpty(fileName)))
CommandLine.ErrorExit(
"\nOne or more of the required arguments is missing or incorrect." +
"\nRun the command with no arguments to see help.");
if(!File.Exists(fileName))
CommandLine.ErrorExit($"\nThe given file {fileName} doesn't exist.");
if(string.IsNullOrEmpty(itemName))
itemName = Path.GetFileName(fileName);
// Create a customer master key (CMK) and store the result
CreateKeyResponse createKeyResponse =
await new AmazonKeyManagementServiceClient().CreateKeyAsync(new CreateKeyRequest());
var kmsEncryptionContext = new Dictionary();
var kmsEncryptionMaterials = new EncryptionMaterialsV2(
createKeyResponse.KeyMetadata.KeyId, KmsType.KmsContext, kmsEncryptionContext);
// Create the object in the bucket, then display the content of the object
var putObjectResponse =
await CreateAndRetrieveObjectAsync(kmsEncryptionMaterials, bucketName, fileName, itemName);
Stream stream = putObjectResponse.ResponseStream;
StreamReader reader = new StreamReader(stream);
Console.WriteLine(reader.ReadToEnd());
}
//
// Method to create and encrypt an object in an S3 bucket
static async Task CreateAndRetrieveObjectAsync(
EncryptionMaterialsV2 materials, string bucketName,
string fileName, string itemName)
{
// CryptoStorageMode.ObjectMetadata is required for KMS EncryptionMaterials
var config = new AmazonS3CryptoConfigurationV2(SecurityProfile.V2AndLegacy)
{
StorageMode = CryptoStorageMode.ObjectMetadata
};
var s3EncClient = new AmazonS3EncryptionClientV2(config, materials);
// Create, encrypt, and put the object
await s3EncClient.PutObjectAsync(new PutObjectRequest
{
BucketName = bucketName,
Key = itemName,
ContentBody = File.ReadAllText(fileName)
});
// Get, decrypt, and return the object
return await s3EncClient.GetObjectAsync(new GetObjectRequest
{
BucketName = bucketName,
Key = itemName
});
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine(
"\nUsage: KmsS3Encryption -b -f [-i ]" +
"\n -b, --bucket-name: The name of an existing S3 bucket." +
"\n -f, --file-name: The name of a text file with content to encrypt and store in S3." +
"\n -i, --item-name: The name you want to use for the item." +
"\n If item-name isn't given, file-name will be used.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
## Weitere Überlegungen
+ Sie können die Ergebnisse dieses Beispiels überprüfen. Rufen Sie dazu die [Amazon S3 S3-Konsole](https://console.aws.amazon.com/s3) auf und öffnen Sie den Bucket, den Sie der Anwendung zur Verfügung gestellt haben. Suchen Sie dann das neue Objekt, laden Sie es herunter und öffnen Sie es in einem Texteditor.
+ Die [AmazonS3 EncryptionClient V2-Klasse](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.AmazonS3EncryptionClientV2.html) implementiert dieselbe Schnittstelle wie die `AmazonS3Client` Standardklasse. Dies erleichtert die Portierung Ihres Codes in die `AmazonS3EncryptionClientV2` Klasse, sodass die Verschlüsselung und Entschlüsselung automatisch und transparent im Client erfolgt.
+ Ein Vorteil der Verwendung eines AWS KMS Schlüssels als Hauptschlüssel besteht darin, dass Sie Ihre eigenen Hauptschlüssel nicht speichern und verwalten müssen. Dies erfolgt durch. AWS Ein zweiter Vorteil besteht darin, dass die `AmazonS3EncryptionClientV2` Klasse von mit der `AmazonS3EncryptionClientV2` Klasse von interoperabel AWS SDK für .NET ist. AWS SDK für Java Das heißt, Sie können mit dem verschlüsseln AWS SDK für Java und mit dem entschlüsseln und AWS SDK für .NET umgekehrt.
**Anmerkung**
Die `AmazonS3EncryptionClientV2` Klasse von AWS SDK für .NET unterstützt KMS-Masterschlüssel nur, wenn sie im Metadatenmodus ausgeführt wird. Der Befehlsdateimodus der `AmazonS3EncryptionClientV2` Klasse von AWS SDK für .NET ist nicht kompatibel mit der `AmazonS3EncryptionClientV2` Klasse von AWS SDK für Java.
+ Weitere Informationen zur clientseitigen Verschlüsselung mit der `AmazonS3EncryptionClientV2` Klasse und zur Funktionsweise der Envelope-Verschlüsselung finden Sie unter [Clientseitige Datenverschlüsselung mit AWS SDK für .NET und Amazon S3](https://aws.amazon.com/blogs/developer/client-side-data-encryption-with-aws-sdk-for-net-and-amazon-s3/).
# Senden von Benachrichtigungen aus der Cloud mit Amazon Simple Notification Service
**Anmerkung**
Die Informationen in diesem Thema beziehen sich speziell auf Projekte, die auf .NET Framework und AWS SDK für .NET Version 3.3 und früher basieren.
Der AWS SDK für .NET unterstützt Amazon Simple Notification Service (Amazon SNS), einen Webservice, der es Anwendungen, Endbenutzern und Geräten ermöglicht, sofort Benachrichtigungen aus der Cloud zu senden. Weitere Informationen finden Sie unter [Amazon SNS](https://aws.amazon.com/sns/).
## Auflisten Ihrer Amazon SNS SNS-Themen
Das folgende Beispiel zeigt, wie Sie Ihre Amazon SNS SNS-Themen, die Abonnements für jedes Thema und die Attribute für jedes Thema auflisten. In diesem Beispiel wird die Standardeinstellung [AmazonSimpleNotificationServiceClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SNS/TSNSClient.html)verwendet.
```
// using Amazon.SimpleNotificationService;
// using Amazon.SimpleNotificationService.Model;
var client = new AmazonSimpleNotificationServiceClient();
var request = new ListTopicsRequest();
var response = new ListTopicsResponse();
do
{
response = client.ListTopics(request);
foreach (var topic in response.Topics)
{
Console.WriteLine("Topic: {0}", topic.TopicArn);
var subs = client.ListSubscriptionsByTopic(
new ListSubscriptionsByTopicRequest
{
TopicArn = topic.TopicArn
});
var ss = subs.Subscriptions;
if (ss.Any())
{
Console.WriteLine(" Subscriptions:");
foreach (var sub in ss)
{
Console.WriteLine(" {0}", sub.SubscriptionArn);
}
}
var attrs = client.GetTopicAttributes(
new GetTopicAttributesRequest
{
TopicArn = topic.TopicArn
}).Attributes;
if (attrs.Any())
{
Console.WriteLine(" Attributes:");
foreach (var attr in attrs)
{
Console.WriteLine(" {0} = {1}", attr.Key, attr.Value);
}
}
Console.WriteLine();
}
request.NextToken = response.NextToken;
} while (!string.IsNullOrEmpty(response.NextToken));
```
## Eine Nachricht an ein Amazon SNS SNS-Thema senden
Das folgende Beispiel zeigt, wie eine Nachricht an ein Amazon SNS SNS-Thema gesendet wird. Das Beispiel verwendet ein Argument, den ARN des Amazon SNS SNS-Themas.
```
using System;
using System.Linq;
using System.Threading.Tasks;
using Amazon;
using Amazon.SimpleNotificationService;
using Amazon.SimpleNotificationService.Model;
namespace SnsSendMessage
{
class Program
{
static void Main(string[] args)
{
/* Topic ARNs must be in the correct format:
* arn:aws:sns:REGION:ACCOUNT_ID:NAME
*
* where:
* REGION is the region in which the topic is created, such as us-west-2
* ACCOUNT_ID is your (typically) 12-character account ID
* NAME is the name of the topic
*/
string topicArn = args[0];
string message = "Hello at " + DateTime.Now.ToShortTimeString();
var client = new AmazonSimpleNotificationServiceClient(region: Amazon.RegionEndpoint.USWest2);
var request = new PublishRequest
{
Message = message,
TopicArn = topicArn
};
try
{
var response = client.Publish(request);
Console.WriteLine("Message sent to topic:");
Console.WriteLine(message);
}
catch (Exception ex)
{
Console.WriteLine("Caught exception publishing request:");
Console.WriteLine(ex.Message);
}
}
}
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/.dotnet/example_code_legacy/SNS/SnsSendMessage.cs), einschließlich Informationen zum Erstellen und Ausführen des Beispiels über die Befehlszeile, finden Sie unter GitHub.
## Senden einer SMS-Nachricht an eine Telefonnummer
Das folgende Beispiel zeigt, wie Sie eine SMS-Nachricht an eine Telefonnummer senden. Das Beispiel verwendet ein Argument, die Telefonnummer, die in einem der beiden in den Kommentaren beschriebenen Formate vorliegen muss.
```
using System;
using System.Linq;
using System.Threading.Tasks;
using Amazon;
using Amazon.SimpleNotificationService;
using Amazon.SimpleNotificationService.Model;
namespace SnsPublish
{
class Program
{
static void Main(string[] args)
{
// US phone numbers must be in the correct format:
// +1 (nnn) nnn-nnnn OR +1nnnnnnnnnn
string number = args[0];
string message = "Hello at " + DateTime.Now.ToShortTimeString();
var client = new AmazonSimpleNotificationServiceClient(region: Amazon.RegionEndpoint.USWest2);
var request = new PublishRequest
{
Message = message,
PhoneNumber = number
};
try
{
var response = client.Publish(request);
Console.WriteLine("Message sent to " + number + ":");
Console.WriteLine(message);
}
catch (Exception ex)
{
Console.WriteLine("Caught exception publishing request:");
Console.WriteLine(ex.Message);
}
}
}
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/.dotnet/example_code_legacy/SNS/SnsPublish.cs), einschließlich Informationen zum Erstellen und Ausführen des Beispiels über die Befehlszeile, finden Sie unter GitHub.
# Nachrichtenübermittlung mit Amazon SQS
Der AWS SDK für .NET unterstützt [Amazon Simple Queue Service (Amazon SQS)](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/), einen Nachrichtenwarteschlangen-Service, der Nachrichten oder Workflows zwischen Komponenten in einem System verarbeitet.
Amazon SQS SQS-Warteschlangen bieten einen Mechanismus, mit dem Sie Nachrichten zwischen Softwarekomponenten wie Microservices, verteilten Systemen und serverlosen Anwendungen senden, speichern und empfangen können. Auf diese Weise können Sie solche Komponenten entkoppeln und müssen kein eigenes Messaging-System entwerfen und betreiben. Informationen zur Funktionsweise von Warteschlangen und Nachrichten in Amazon SQS finden Sie in den Amazon [SQS-Tutorials und unter Basic Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-other-tutorials.html) [architecture im Amazon](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-basic-architecture.html) [Simple Queue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/) Service Developer Guide.
**Wichtig**
Aufgrund des verteilten Charakters von Warteschlangen kann Amazon SQS nicht garantieren, dass Sie Nachrichten in der genauen Reihenfolge erhalten, in der sie gesendet wurden. Wenn Sie die Nachrichtenreihenfolge beibehalten müssen, verwenden Sie eine [Amazon SQS FIFO-Warteschlange](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-fifo-queues.html).
## APIs
Das AWS SDK für .NET bietet APIs Amazon SQS-Kunden. Sie APIs ermöglichen es Ihnen, mit Amazon SQS SQS-Funktionen wie Warteschlangen und Nachrichten zu arbeiten. Dieser Abschnitt enthält eine kleine Anzahl von Beispielen, die Ihnen zeigen, welchen Mustern Sie bei der Arbeit mit diesen Modellen folgen können. APIs Den vollständigen Satz von finden Sie in der APIs [AWS SDK für .NET API-Referenz](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/) (und scrollen Sie zu „Amazon.sqs“).
Die Amazon SQS APIs werden durch das [AWSSDK NuGet .SQS-Paket](https://www.nuget.org/packages/AWSSDK.SQS) bereitgestellt.
## Voraussetzungen
Bevor Sie beginnen, stellen Sie sicher, dass Sie [Ihre Umgebung und Ihr Projekt eingerichtet](net-dg-config.md) haben. Lesen Sie auch die Informationen unter[SDK-Funktionen](net-dg-sdk-features.md).
## Topics
**Topics**
+ [APIs](#w2aac19c15c25b9)
+ [Voraussetzungen](#w2aac19c15c25c11)
+ [Topics](#w2aac19c15c25c13)
+ [Erstellen von Warteschlangen](CreateQueue.md)
+ [Warteschlangen werden aktualisiert](UpdateSqsQueue.md)
+ [Warteschlangen löschen](DeleteSqsQueue.md)
+ [Senden von Nachrichten](SendMessage.md)
+ [Empfangen von Nachrichten](ReceiveMessage.md)
# Amazon SQS SQS-Warteschlangen erstellen
Dieses Beispiel zeigt Ihnen, wie Sie die verwenden, um eine Amazon SQS SQS-Warteschlange AWS SDK für .NET zu erstellen. Die Anwendung erstellt eine [Warteschlange für unzustellbare Briefe](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html), wenn Sie den ARN für eine nicht angeben. Anschließend erstellt sie eine Standard-Nachrichtenwarteschlange, die eine Warteschlange für unzustellbare Nachrichten enthält (die, die Sie angegeben haben oder die, die erstellt wurde).
Wenn Sie keine Befehlszeilenargumente angeben, zeigt die Anwendung einfach Informationen über alle vorhandenen Warteschlangen an.
Die folgenden Abschnitte enthalten Auszüge aus diesem Beispiel. Der [vollständige Code für das Beispiel](#CreateQueue-complete-code) wird danach angezeigt und kann unverändert erstellt und ausgeführt werden.
**Topics**
+ [Bestehende Warteschlangen anzeigen](#CreateQueue-show-queues)
+ [Erstellen Sie die Warteschlange](#CreateQueue-create-queue)
+ [Den ARN einer Warteschlange abrufen](#CreateQueue-get-arn)
+ [Vollständiger Code](#CreateQueue-complete-code)
+ [Weitere Überlegungen](#CreateQueue-additional)
## Bestehende Warteschlangen anzeigen
Der folgende Ausschnitt zeigt eine Liste der vorhandenen Warteschlangen in der Region des SQS-Clients und die Attribute jeder Warteschlange.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#CreateQueue-complete-code) Snippet verwendet wird.
```
//
// Method to show a list of the existing queues
private static async Task ShowQueues(IAmazonSQS sqsClient)
{
ListQueuesResponse responseList = await sqsClient.ListQueuesAsync("");
Console.WriteLine();
foreach(string qUrl in responseList.QueueUrls)
{
// Get and show all attributes. Could also get a subset.
await ShowAllAttributes(sqsClient, qUrl);
}
}
//
// Method to show all attributes of a queue
private static async Task ShowAllAttributes(IAmazonSQS sqsClient, string qUrl)
{
var attributes = new List{ QueueAttributeName.All };
GetQueueAttributesResponse responseGetAtt =
await sqsClient.GetQueueAttributesAsync(qUrl, attributes);
Console.WriteLine($"Queue: {qUrl}");
foreach(var att in responseGetAtt.Attributes)
Console.WriteLine($"\t{att.Key}: {att.Value}");
}
```
## Erstellen Sie die Warteschlange
Das folgende Snippet erstellt eine Warteschlange. Das Snippet beinhaltet die Verwendung einer Warteschlange für unzustellbare Briefe, für Ihre Warteschlangen ist jedoch nicht unbedingt eine Warteschlange erforderlich.
Das Beispiel [am Ende dieses Themas zeigt, wie dieser Codeausschnitt](#CreateQueue-complete-code) verwendet wird.
```
//
// Method to create a queue. Returns the queue URL.
private static async Task CreateQueue(
IAmazonSQS sqsClient, string qName, string deadLetterQueueUrl=null,
string maxReceiveCount=null, string receiveWaitTime=null)
{
var attrs = new Dictionary();
// If a dead-letter queue is given, create a message queue
if(!string.IsNullOrEmpty(deadLetterQueueUrl))
{
attrs.Add(QueueAttributeName.ReceiveMessageWaitTimeSeconds, receiveWaitTime);
attrs.Add(QueueAttributeName.RedrivePolicy,
$"{{\"deadLetterTargetArn\":\"{await GetQueueArn(sqsClient, deadLetterQueueUrl)}\"," +
$"\"maxReceiveCount\":\"{maxReceiveCount}\"}}");
// Add other attributes for the message queue such as VisibilityTimeout
}
// If no dead-letter queue is given, create one of those instead
//else
//{
// // Add attributes for the dead-letter queue as needed
// attrs.Add();
//}
// Create the queue
CreateQueueResponse responseCreate = await sqsClient.CreateQueueAsync(
new CreateQueueRequest{QueueName = qName, Attributes = attrs});
return responseCreate.QueueUrl;
}
```
## Den ARN einer Warteschlange abrufen
Das folgende Snippet ruft den ARN der Warteschlange ab, die durch die angegebene Warteschlangen-URL identifiziert wird.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#CreateQueue-complete-code) Snippet verwendet wird.
```
//
// Method to get the ARN of a queue
private static async Task GetQueueArn(IAmazonSQS sqsClient, string qUrl)
{
GetQueueAttributesResponse responseGetAtt = await sqsClient.GetQueueAttributesAsync(
qUrl, new List{QueueAttributeName.QueueArn});
return responseGetAtt.QueueARN;
}
```
## Vollständiger Code
Dieser Abschnitt enthält relevante Referenzen und den vollständigen Code für dieses Beispiel.
### SDK-Referenzen
NuGet Pakete:
+ [AWSSDK.SQS](https://www.nuget.org/packages/AWSSDK.SQS)
Elemente der Programmierung:
+ [Namespace Amazon.sqs](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/NSQS.html)
Klasse [Amazon SQSClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSQSClient.html)
Klasse [QueueAttributeName](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TQueueAttributeName.html)
+ [Namespace Amazon.SQS.Model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/NSQSModel.html)
Klasse [CreateQueueRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TCreateQueueRequest.html)
Klasse [CreateQueueResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TCreateQueueResponse.html)
Klasse [GetQueueAttributesResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TGetQueueAttributesResponse.html)
Klasse [ListQueuesResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TListQueuesResponse.html)
### Der Code
```
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using Amazon.SQS;
using Amazon.SQS.Model;
namespace SQSCreateQueue
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to create a queue
class Program
{
private const string MaxReceiveCount = "10";
private const string ReceiveMessageWaitTime = "2";
private const int MaxArgs = 3;
static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if(parsedArgs.Count > MaxArgs)
CommandLine.ErrorExit(
"\nToo many command-line arguments.\nRun the command with no arguments to see help.");
// Create the Amazon SQS client
var sqsClient = new AmazonSQSClient();
// In the case of no command-line arguments, just show help and the existing queues
if(parsedArgs.Count == 0)
{
PrintHelp();
Console.WriteLine("\nNo arguments specified.");
Console.Write("Do you want to see a list of the existing queues? ((y) or n): ");
string response = Console.ReadLine();
if((string.IsNullOrEmpty(response)) || (response.ToLower() == "y"))
await ShowQueues(sqsClient);
return;
}
// Get the application arguments from the parsed list
string queueName =
CommandLine.GetArgument(parsedArgs, null, "-q", "--queue-name");
string deadLetterQueueUrl =
CommandLine.GetArgument(parsedArgs, null, "-d", "--dead-letter-queue");
string maxReceiveCount =
CommandLine.GetArgument(parsedArgs, MaxReceiveCount, "-m", "--max-receive-count");
string receiveWaitTime =
CommandLine.GetArgument(parsedArgs, ReceiveMessageWaitTime, "-w", "--wait-time");
if(string.IsNullOrEmpty(queueName))
CommandLine.ErrorExit(
"\nYou must supply a queue name.\nRun the command with no arguments to see help.");
// If a dead-letter queue wasn't given, create one
if(string.IsNullOrEmpty(deadLetterQueueUrl))
{
Console.WriteLine("\nNo dead-letter queue was specified. Creating one...");
deadLetterQueueUrl = await CreateQueue(sqsClient, queueName + "__dlq");
Console.WriteLine($"Your new dead-letter queue:");
await ShowAllAttributes(sqsClient, deadLetterQueueUrl);
}
// Create the message queue
string messageQueueUrl = await CreateQueue(
sqsClient, queueName, deadLetterQueueUrl, maxReceiveCount, receiveWaitTime);
Console.WriteLine($"Your new message queue:");
await ShowAllAttributes(sqsClient, messageQueueUrl);
}
//
// Method to show a list of the existing queues
private static async Task ShowQueues(IAmazonSQS sqsClient)
{
ListQueuesResponse responseList = await sqsClient.ListQueuesAsync("");
Console.WriteLine();
foreach(string qUrl in responseList.QueueUrls)
{
// Get and show all attributes. Could also get a subset.
await ShowAllAttributes(sqsClient, qUrl);
}
}
//
// Method to create a queue. Returns the queue URL.
private static async Task CreateQueue(
IAmazonSQS sqsClient, string qName, string deadLetterQueueUrl=null,
string maxReceiveCount=null, string receiveWaitTime=null)
{
var attrs = new Dictionary();
// If a dead-letter queue is given, create a message queue
if(!string.IsNullOrEmpty(deadLetterQueueUrl))
{
attrs.Add(QueueAttributeName.ReceiveMessageWaitTimeSeconds, receiveWaitTime);
attrs.Add(QueueAttributeName.RedrivePolicy,
$"{{\"deadLetterTargetArn\":\"{await GetQueueArn(sqsClient, deadLetterQueueUrl)}\"," +
$"\"maxReceiveCount\":\"{maxReceiveCount}\"}}");
// Add other attributes for the message queue such as VisibilityTimeout
}
// If no dead-letter queue is given, create one of those instead
//else
//{
// // Add attributes for the dead-letter queue as needed
// attrs.Add();
//}
// Create the queue
CreateQueueResponse responseCreate = await sqsClient.CreateQueueAsync(
new CreateQueueRequest{QueueName = qName, Attributes = attrs});
return responseCreate.QueueUrl;
}
//
// Method to get the ARN of a queue
private static async Task GetQueueArn(IAmazonSQS sqsClient, string qUrl)
{
GetQueueAttributesResponse responseGetAtt = await sqsClient.GetQueueAttributesAsync(
qUrl, new List{QueueAttributeName.QueueArn});
return responseGetAtt.QueueARN;
}
//
// Method to show all attributes of a queue
private static async Task ShowAllAttributes(IAmazonSQS sqsClient, string qUrl)
{
var attributes = new List{ QueueAttributeName.All };
GetQueueAttributesResponse responseGetAtt =
await sqsClient.GetQueueAttributesAsync(qUrl, attributes);
Console.WriteLine($"Queue: {qUrl}");
foreach(var att in responseGetAtt.Attributes)
Console.WriteLine($"\t{att.Key}: {att.Value}");
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine(
"\nUsage: SQSCreateQueue -q [-d ]" +
" [-m ] [-w ]" +
"\n -q, --queue-name: The name of the queue you want to create." +
"\n -d, --dead-letter-queue: The URL of an existing queue to be used as the dead-letter queue."+
"\n If this argument isn't supplied, a new dead-letter queue will be created." +
"\n -m, --max-receive-count: The value for maxReceiveCount in the RedrivePolicy of the queue." +
$"\n Default is {MaxReceiveCount}." +
"\n -w, --wait-time: The value for ReceiveMessageWaitTimeSeconds of the queue for long polling." +
$"\n Default is {ReceiveMessageWaitTime}.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
## Weitere Überlegungen
+ Ihr Warteschlangenname muss aus alphanumerischen Zeichen, Bindestrichen und Unterstrichen bestehen.
+ Bei Warteschlangennamen und Warteschlangen wird zwischen Groß- und Kleinschreibung unterschieden URLs
+ Wenn Sie die Warteschlangen-URL benötigen, aber nur den Warteschlangennamen kennen, verwenden Sie eine der `AmazonSQSClient.GetQueueUrlAsync` Methoden.
+ Informationen zu den verschiedenen Warteschlangenattributen, die Sie festlegen können, finden Sie [CreateQueueRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TCreateQueueRequest.html)in der [AWS SDK für .NET API-Referenz](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/) oder [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)in der [Amazon Simple Queue Service API-Referenz](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/).
+ In diesem Beispiel wird eine lange Abfrage für alle Nachrichten in der von Ihnen erstellten Warteschlange spezifiziert. Dies erfolgt mithilfe des `ReceiveMessageWaitTimeSeconds` Attributs.
Sie können auch lange Abfragen während eines Aufrufs der `ReceiveMessageAsync` Methoden der [SQSClientAmazon-Klasse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSQSClient.html) angeben. Weitere Informationen finden Sie unter [Empfangen Amazon SQS SQS-Nachrichten](ReceiveMessage.md).
Informationen zu kurzen Abfragen im Vergleich zu langen Abfragen finden Sie unter [Kurze und lange Abfragen](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-short-and-long-polling.html) im *Amazon Simple Queue Service* Developer Guide.
+ Eine Warteschlange für unzustellbare Nachrichten kann von anderen (Quell-) Warteschlangen gezielt für Nachrichten verwendet werden, die nicht erfolgreich verarbeitet wurden. Weitere Informationen finden Sie unter [Amazon SQS Dead-Letter-Warteschlangen](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html) im Amazon Simple Queue Service Developer Guide.
+ Sie können die Liste der Warteschlangen und die Ergebnisse dieses Beispiels auch in der [Amazon SQS SQS-Konsole](https://console.aws.amazon.com/sqs) sehen.
# Amazon SQS SQS-Warteschlangen aktualisieren
Dieses Beispiel zeigt Ihnen, wie Sie die verwenden, um eine Amazon SQS SQS-Warteschlange AWS SDK für .NET zu aktualisieren. Nach einigen Prüfungen aktualisiert die Anwendung das angegebene Attribut mit dem angegebenen Wert und zeigt dann alle Attribute für die Warteschlange an.
Wenn nur die Warteschlangen-URL in den Befehlszeilenargumenten enthalten ist, zeigt die Anwendung einfach alle Attribute für die Warteschlange an.
Die folgenden Abschnitte enthalten Auszüge aus diesem Beispiel. Der [vollständige Code für das Beispiel](#UpdateSqsQueue-complete-code) wird danach angezeigt und kann unverändert erstellt und ausgeführt werden.
**Topics**
+ [Queue-Attribute anzeigen](#UpdateSqsQueue-show-attributes)
+ [Überprüfen Sie den Attributnamen](#UpdateSqsQueue-validate-attribute)
+ [Warteschlangenattribut aktualisieren](#UpdateSqsQueue-update-attribute)
+ [Vollständiger Code](#UpdateSqsQueue-complete-code)
+ [Weitere Überlegungen](#UpdateSqsQueue-additional)
## Queue-Attribute anzeigen
Das folgende Snippet zeigt die Attribute der Warteschlange, die durch die angegebene Warteschlangen-URL identifiziert werden.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#UpdateSqsQueue-complete-code) Snippet verwendet wird.
```
//
// Method to show all attributes of a queue
private static async Task ShowAllAttributes(IAmazonSQS sqsClient, string qUrl)
{
GetQueueAttributesResponse responseGetAtt =
await sqsClient.GetQueueAttributesAsync(qUrl,
new List{ QueueAttributeName.All });
Console.WriteLine($"Queue: {qUrl}");
foreach(var att in responseGetAtt.Attributes)
Console.WriteLine($"\t{att.Key}: {att.Value}");
}
```
## Überprüfen Sie den Attributnamen
Der folgende Ausschnitt validiert den Namen des Attributs, das aktualisiert wird.
Das Beispiel [am Ende dieses Themas zeigt, wie dieser](#UpdateSqsQueue-complete-code) Codeausschnitt verwendet wird.
```
//
// Method to check the name of the attribute
private static bool ValidAttribute(string attribute)
{
var attOk = false;
var qAttNameType = typeof(QueueAttributeName);
List qAttNamefields = new List();
foreach(var field in qAttNameType.GetFields())
qAttNamefields.Add(field.Name);
foreach(var name in qAttNamefields)
if(attribute == name) { attOk = true; break; }
return attOk;
}
```
## Warteschlangenattribut aktualisieren
Das folgende Snippet aktualisiert ein Attribut der Warteschlange, das durch die angegebene Warteschlangen-URL identifiziert wird.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#UpdateSqsQueue-complete-code) Snippet verwendet wird.
```
//
// Method to update a queue attribute
private static async Task UpdateAttribute(
IAmazonSQS sqsClient, string qUrl, string attribute, string value)
{
await sqsClient.SetQueueAttributesAsync(qUrl,
new Dictionary{{attribute, value}});
}
```
## Vollständiger Code
Dieser Abschnitt enthält relevante Referenzen und den vollständigen Code für dieses Beispiel.
### SDK-Referenzen
NuGet Pakete:
+ [AWSSDK.SQS](https://www.nuget.org/packages/AWSSDK.SQS)
Elemente der Programmierung:
+ [Namespace Amazon.sqs](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/NSQS.html)
Klasse [Amazon SQSClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSQSClient.html)
Klasse [QueueAttributeName](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TQueueAttributeName.html)
+ [Namespace Amazon.SQS.Model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/NSQSModel.html)
Klasse [GetQueueAttributesResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TGetQueueAttributesResponse.html)
### Der Code
```
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Amazon.SQS;
using Amazon.SQS.Model;
namespace SQSUpdateQueue
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to update a queue
class Program
{
private const int MaxArgs = 3;
private const int InvalidArgCount = 2;
static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if(parsedArgs.Count == 0)
{
PrintHelp();
return;
}
if((parsedArgs.Count > MaxArgs) || (parsedArgs.Count == InvalidArgCount))
CommandLine.ErrorExit("\nThe number of command-line arguments is incorrect." +
"\nRun the command with no arguments to see help.");
// Get the application arguments from the parsed list
var qUrl = CommandLine.GetArgument(parsedArgs, null, "-q");
var attribute = CommandLine.GetArgument(parsedArgs, null, "-a");
var value = CommandLine.GetArgument(parsedArgs, null, "-v", "--value");
if(string.IsNullOrEmpty(qUrl))
CommandLine.ErrorExit("\nYou must supply at least a queue URL." +
"\nRun the command with no arguments to see help.");
// Create the Amazon SQS client
var sqsClient = new AmazonSQSClient();
// In the case of one command-line argument, just show the attributes for the queue
if(parsedArgs.Count == 1)
await ShowAllAttributes(sqsClient, qUrl);
// Otherwise, attempt to update the given queue attribute with the given value
else
{
// Check to see if the attribute is valid
if(ValidAttribute(attribute))
{
// Perform the update and then show all the attributes of the queue
await UpdateAttribute(sqsClient, qUrl, attribute, value);
await ShowAllAttributes(sqsClient, qUrl);
}
else
{
Console.WriteLine($"\nThe given attribute name, {attribute}, isn't valid.");
}
}
}
//
// Method to show all attributes of a queue
private static async Task ShowAllAttributes(IAmazonSQS sqsClient, string qUrl)
{
GetQueueAttributesResponse responseGetAtt =
await sqsClient.GetQueueAttributesAsync(qUrl,
new List{ QueueAttributeName.All });
Console.WriteLine($"Queue: {qUrl}");
foreach(var att in responseGetAtt.Attributes)
Console.WriteLine($"\t{att.Key}: {att.Value}");
}
//
// Method to check the name of the attribute
private static bool ValidAttribute(string attribute)
{
var attOk = false;
var qAttNameType = typeof(QueueAttributeName);
List qAttNamefields = new List();
foreach(var field in qAttNameType.GetFields())
qAttNamefields.Add(field.Name);
foreach(var name in qAttNamefields)
if(attribute == name) { attOk = true; break; }
return attOk;
}
//
// Method to update a queue attribute
private static async Task UpdateAttribute(
IAmazonSQS sqsClient, string qUrl, string attribute, string value)
{
await sqsClient.SetQueueAttributesAsync(qUrl,
new Dictionary{{attribute, value}});
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine("\nUsage: SQSUpdateQueue -q queue_url [-a attribute -v value]");
Console.WriteLine(" -q: The URL of the queue you want to update.");
Console.WriteLine(" -a: The name of the attribute to update.");
Console.WriteLine(" -v, --value: The value to assign to the attribute.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
## Weitere Überlegungen
+ Um das `RedrivePolicy` Attribut zu aktualisieren, müssen Sie je nach Betriebssystem den gesamten Wert in Anführungszeichen setzen und die Anführungszeichen für die key/value Paare maskieren.
Unter Windows ist der Wert beispielsweise ähnlich wie folgt aufgebaut:
```
"{\"deadLetterTargetArn\":\"DEAD_LETTER-QUEUE-ARN\",\"maxReceiveCount\":\"10\"}"
```
# Löschen von Amazon SQS SQS-Warteschlangen
Dieses Beispiel zeigt Ihnen, wie Sie die verwenden, um eine Amazon SQS SQS-Warteschlange AWS SDK für .NET zu löschen. Die Anwendung löscht die Warteschlange, wartet bis zu einer bestimmten Zeit, bis die Warteschlange gelöscht ist, und zeigt dann eine Liste der verbleibenden Warteschlangen an.
Wenn Sie keine Befehlszeilenargumente angeben, zeigt die Anwendung einfach eine Liste der vorhandenen Warteschlangen an.
Die folgenden Abschnitte enthalten Auszüge aus diesem Beispiel. Der [vollständige Code für das Beispiel](#DeleteSqsQueue-complete-code) wird danach angezeigt und kann unverändert erstellt und ausgeführt werden.
**Topics**
+ [Lösche die Warteschlange](#DeleteSqsQueue-delete-queue)
+ [Warten Sie, bis die Warteschlange weg ist](#DeleteSqsQueue-wait)
+ [Zeigt eine Liste vorhandener Warteschlangen](#DeleteSqsQueue-list-queues)
+ [Vollständiger Code](#DeleteSqsQueue-complete-code)
+ [Weitere Überlegungen](#DeleteSqsQueue-additional)
## Lösche die Warteschlange
Das folgende Snippet löscht die Warteschlange, die durch die angegebene Warteschlangen-URL identifiziert wurde.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#DeleteSqsQueue-complete-code) Snippet verwendet wird.
```
//
// Method to delete an SQS queue
private static async Task DeleteQueue(IAmazonSQS sqsClient, string qUrl)
{
Console.WriteLine($"Deleting queue {qUrl}...");
await sqsClient.DeleteQueueAsync(qUrl);
Console.WriteLine($"Queue {qUrl} has been deleted.");
}
```
## Warten Sie, bis die Warteschlange weg ist
Das folgende Snippet wartet, bis der Löschvorgang abgeschlossen ist, was 60 Sekunden dauern kann.
Das Beispiel [am Ende dieses Themas zeigt, wie dieser](#DeleteSqsQueue-complete-code) Codeausschnitt verwendet wird.
```
//
// Method to wait up to a given number of seconds
private static async Task Wait(
IAmazonSQS sqsClient, int numSeconds, string qUrl)
{
Console.WriteLine($"Waiting for up to {numSeconds} seconds.");
Console.WriteLine("Press any key to stop waiting. (Response might be slightly delayed.)");
for(int i=0; i
Der folgende Ausschnitt zeigt eine Liste der vorhandenen Warteschlangen in der Region des SQS-Clients.
Das Beispiel [am Ende dieses Themas zeigt, wie dieser Codeausschnitt](#DeleteSqsQueue-complete-code) verwendet wird.
```
//
// Method to show a list of the existing queues
private static async Task ListQueues(IAmazonSQS sqsClient)
{
ListQueuesResponse responseList = await sqsClient.ListQueuesAsync("");
Console.WriteLine("\nList of queues:");
foreach(var qUrl in responseList.QueueUrls)
Console.WriteLine($"- {qUrl}");
}
```
## Vollständiger Code
Dieser Abschnitt enthält relevante Referenzen und den vollständigen Code für dieses Beispiel.
### SDK-Referenzen
NuGet Pakete:
+ [AWSSDK.SQS](https://www.nuget.org/packages/AWSSDK.SQS)
Elemente der Programmierung:
+ [Namespace Amazon.sqs](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/NSQS.html)
Klasse [Amazon SQSClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSQSClient.html)
+ [Namespace Amazon.SQS.Model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/NSQSModel.html)
Klasse [ListQueuesResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TListQueuesResponse.html)
### Der Code
```
using System;
using System.Threading;
using System.Threading.Tasks;
using Amazon.SQS;
using Amazon.SQS.Model;
namespace SQSDeleteQueue
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to update a queue
class Program
{
private const int TimeToWait = 60;
static async Task Main(string[] args)
{
// Create the Amazon SQS client
var sqsClient = new AmazonSQSClient();
// If no command-line arguments, just show a list of the queues
if(args.Length == 0)
{
Console.WriteLine("\nUsage: SQSCreateQueue queue_url");
Console.WriteLine(" queue_url - The URL of the queue you want to delete.");
Console.WriteLine("\nNo arguments specified.");
Console.Write("Do you want to see a list of the existing queues? ((y) or n): ");
var response = Console.ReadLine();
if((string.IsNullOrEmpty(response)) || (response.ToLower() == "y"))
await ListQueues(sqsClient);
return;
}
// If given a queue URL, delete that queue
if(args[0].StartsWith("https://sqs."))
{
// Delete the queue
await DeleteQueue(sqsClient, args[0]);
// Wait for a little while because it takes a while for the queue to disappear
await Wait(sqsClient, TimeToWait, args[0]);
// Show a list of the remaining queues
await ListQueues(sqsClient);
}
else
{
Console.WriteLine("The command-line argument isn't a queue URL:");
Console.WriteLine($"{args[0]}");
}
}
//
// Method to delete an SQS queue
private static async Task DeleteQueue(IAmazonSQS sqsClient, string qUrl)
{
Console.WriteLine($"Deleting queue {qUrl}...");
await sqsClient.DeleteQueueAsync(qUrl);
Console.WriteLine($"Queue {qUrl} has been deleted.");
}
//
// Method to wait up to a given number of seconds
private static async Task Wait(
IAmazonSQS sqsClient, int numSeconds, string qUrl)
{
Console.WriteLine($"Waiting for up to {numSeconds} seconds.");
Console.WriteLine("Press any key to stop waiting. (Response might be slightly delayed.)");
for(int i=0; i
+ Der `DeleteQueueAsync` API-Aufruf überprüft nicht, ob die Warteschlange, die Sie löschen, als Warteschlange für unzustellbare Briefe verwendet wird. Ein ausgefeilteres Verfahren könnte dies überprüfen.
+ Sie können die Liste der Warteschlangen und die Ergebnisse dieses Beispiels auch in der [Amazon SQS SQS-Konsole](https://console.aws.amazon.com/sqs) sehen.
# Amazon SQS SQS-Nachrichten senden
Dieses Beispiel zeigt Ihnen, wie Sie Nachrichten AWS SDK für .NET an eine Amazon SQS SQS-Warteschlange senden, die Sie [programmgesteuert](CreateQueue.md) oder mithilfe der [Amazon](https://console.aws.amazon.com/sqs) SQS SQS-Konsole erstellen können. Die Anwendung sendet eine einzelne Nachricht an die Warteschlange und anschließend einen Stapel von Nachrichten. Die Anwendung wartet dann auf Benutzereingaben, bei denen es sich um zusätzliche Nachrichten handeln kann, die an die Warteschlange gesendet werden sollen, oder um eine Aufforderung zum Beenden der Anwendung.
Dieses und das [nächste Beispiel für den Empfang von Nachrichten](ReceiveMessage.md) können zusammen verwendet werden, um den Nachrichtenfluss in Amazon SQS zu sehen.
Die folgenden Abschnitte enthalten Auszüge aus diesem Beispiel. Der [vollständige Code für das Beispiel](#SendMessage-complete-code) wird danach angezeigt und kann unverändert erstellt und ausgeführt werden.
**Topics**
+ [Senden einer Nachricht](#SendMessage-send-message)
+ [Senden Sie einen Stapel von Nachrichten](#SendMessage-send-batch)
+ [Löscht alle Nachrichten aus der Warteschlange](#SendMessage-purge-messages)
+ [Vollständiger Code](#SendMessage-complete-code)
+ [Weitere Überlegungen](#SendMessage-additional)
## Senden einer Nachricht
Das folgende Snippet sendet eine Nachricht an die Warteschlange, die durch die angegebene Warteschlangen-URL identifiziert wird.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#SendMessage-complete-code) Snippet verwendet wird.
```
//
// Method to put a message on a queue
// Could be expanded to include message attributes, etc., in a SendMessageRequest
private static async Task SendMessage(
IAmazonSQS sqsClient, string qUrl, string messageBody)
{
SendMessageResponse responseSendMsg =
await sqsClient.SendMessageAsync(qUrl, messageBody);
Console.WriteLine($"Message added to queue\n {qUrl}");
Console.WriteLine($"HttpStatusCode: {responseSendMsg.HttpStatusCode}");
}
```
## Senden Sie einen Stapel von Nachrichten
Das folgende Snippet sendet einen Stapel von Nachrichten an die Warteschlange, die durch die angegebene Warteschlangen-URL identifiziert wird.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#SendMessage-complete-code) Snippet verwendet wird.
```
//
// Method to put a batch of messages on a queue
// Could be expanded to include message attributes, etc.,
// in the SendMessageBatchRequestEntry objects
private static async Task SendMessageBatch(
IAmazonSQS sqsClient, string qUrl, List messages)
{
Console.WriteLine($"\nSending a batch of messages to queue\n {qUrl}");
SendMessageBatchResponse responseSendBatch =
await sqsClient.SendMessageBatchAsync(qUrl, messages);
// Could test responseSendBatch.Failed here
foreach(SendMessageBatchResultEntry entry in responseSendBatch.Successful)
Console.WriteLine($"Message {entry.Id} successfully queued.");
}
```
## Löscht alle Nachrichten aus der Warteschlange
Das folgende Snippet löscht alle Nachrichten aus der Warteschlange, die durch die angegebene Warteschlangen-URL identifiziert wird. Dies wird auch als *Löschen* der Warteschlange bezeichnet.
Das Beispiel [am Ende dieses Themas zeigt, wie dieser](#SendMessage-complete-code) Codeausschnitt verwendet wird.
```
//
// Method to delete all messages from the queue
private static async Task DeleteAllMessages(IAmazonSQS sqsClient, string qUrl)
{
Console.WriteLine($"\nPurging messages from queue\n {qUrl}...");
PurgeQueueResponse responsePurge = await sqsClient.PurgeQueueAsync(qUrl);
Console.WriteLine($"HttpStatusCode: {responsePurge.HttpStatusCode}");
}
```
## Vollständiger Code
Dieser Abschnitt enthält relevante Referenzen und den vollständigen Code für dieses Beispiel.
### SDK-Referenzen
NuGet Pakete:
+ [AWSSDK.SQS](https://www.nuget.org/packages/AWSSDK.SQS)
Elemente der Programmierung:
+ [Namespace Amazon.sqs](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/NSQS.html)
Klasse [Amazon SQSClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSQSClient.html)
+ [Namespace Amazon.SQS.Model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/NSQSModel.html)
Klasse [PurgeQueueResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TPurgeQueueResponse.html)
Klasse [SendMessageBatchResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSendMessageBatchResponse.html)
Klasse [SendMessageResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSendMessageResponse.html)
Klasse [SendMessageBatchRequestEntry](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSendMessageBatchRequestEntry.html)
Klasse [SendMessageBatchResultEntry](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSendMessageBatchResultEntry.html)
### Der Code
```
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Amazon.SQS;
using Amazon.SQS.Model;
namespace SQSSendMessages
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to send messages to a queue
class Program
{
// Some example messages to send to the queue
private const string JsonMessage = "{\"product\":[{\"name\":\"Product A\",\"price\": \"32\"},{\"name\": \"Product B\",\"price\": \"27\"}]}";
private const string XmlMessage = "";
private const string CustomMessage = "||product|Product A|32||product|Product B|27||";
private const string TextMessage = "Just a plain text message.";
static async Task Main(string[] args)
{
// Do some checks on the command-line
if(args.Length == 0)
{
Console.WriteLine("\nUsage: SQSSendMessages queue_url");
Console.WriteLine(" queue_url - The URL of an existing SQS queue.");
return;
}
if(!args[0].StartsWith("https://sqs."))
{
Console.WriteLine("\nThe command-line argument isn't a queue URL:");
Console.WriteLine($"{args[0]}");
return;
}
// Create the Amazon SQS client
var sqsClient = new AmazonSQSClient();
// (could verify that the queue exists)
// Send some example messages to the given queue
// A single message
await SendMessage(sqsClient, args[0], JsonMessage);
// A batch of messages
var batchMessages = new List{
new SendMessageBatchRequestEntry("xmlMsg", XmlMessage),
new SendMessageBatchRequestEntry("customeMsg", CustomMessage),
new SendMessageBatchRequestEntry("textMsg", TextMessage)};
await SendMessageBatch(sqsClient, args[0], batchMessages);
// Let the user send their own messages or quit
await InteractWithUser(sqsClient, args[0]);
// Delete all messages that are still in the queue
await DeleteAllMessages(sqsClient, args[0]);
}
//
// Method to put a message on a queue
// Could be expanded to include message attributes, etc., in a SendMessageRequest
private static async Task SendMessage(
IAmazonSQS sqsClient, string qUrl, string messageBody)
{
SendMessageResponse responseSendMsg =
await sqsClient.SendMessageAsync(qUrl, messageBody);
Console.WriteLine($"Message added to queue\n {qUrl}");
Console.WriteLine($"HttpStatusCode: {responseSendMsg.HttpStatusCode}");
}
//
// Method to put a batch of messages on a queue
// Could be expanded to include message attributes, etc.,
// in the SendMessageBatchRequestEntry objects
private static async Task SendMessageBatch(
IAmazonSQS sqsClient, string qUrl, List messages)
{
Console.WriteLine($"\nSending a batch of messages to queue\n {qUrl}");
SendMessageBatchResponse responseSendBatch =
await sqsClient.SendMessageBatchAsync(qUrl, messages);
// Could test responseSendBatch.Failed here
foreach(SendMessageBatchResultEntry entry in responseSendBatch.Successful)
Console.WriteLine($"Message {entry.Id} successfully queued.");
}
//
// Method to get input from the user
// They can provide messages to put in the queue or exit the application
private static async Task InteractWithUser(IAmazonSQS sqsClient, string qUrl)
{
string response;
while (true)
{
// Get the user's input
Console.WriteLine("\nType a message for the queue or \"exit\" to quit:");
response = Console.ReadLine();
if(response.ToLower() == "exit") break;
// Put the user's message in the queue
await SendMessage(sqsClient, qUrl, response);
}
}
//
// Method to delete all messages from the queue
private static async Task DeleteAllMessages(IAmazonSQS sqsClient, string qUrl)
{
Console.WriteLine($"\nPurging messages from queue\n {qUrl}...");
PurgeQueueResponse responsePurge = await sqsClient.PurgeQueueAsync(qUrl);
Console.WriteLine($"HttpStatusCode: {responsePurge.HttpStatusCode}");
}
}
}
```
## Weitere Überlegungen
+ Informationen zu verschiedenen Beschränkungen für Nachrichten, einschließlich der zulässigen Zeichen, finden Sie unter [Kontingente für Nachrichten](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-quotas.html#quotas-messages) im [Amazon Simple Queue Service Developer Guide](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/).
+ Nachrichten bleiben in Warteschlangen, bis sie gelöscht werden oder die Warteschlange gelöscht wird. Wenn eine Nachricht von einer Anwendung empfangen wurde, ist sie in der Warteschlange nicht sichtbar, obwohl sie noch in der Warteschlange vorhanden ist. Weitere Informationen zu Sichtbarkeits-Timeouts finden Sie unter [Amazon SQS SQS-Sichtbarkeits-Timeout](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AboutVT.html).
+ Zusätzlich zum Nachrichtentext können Sie Nachrichten auch Attribute hinzufügen. Weitere Informationen finden Sie unter [Nachrichtenmetadaten](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-metadata.html).
# Empfangen Amazon SQS SQS-Nachrichten
Dieses Beispiel zeigt Ihnen, wie Sie die verwenden, AWS SDK für .NET um Nachrichten aus einer Amazon SQS SQS-Warteschlange zu empfangen, die Sie [programmgesteuert](CreateQueue.md) oder mithilfe der [Amazon](https://console.aws.amazon.com/sqs) SQS SQS-Konsole erstellen können. Die Anwendung liest eine einzelne Nachricht aus der Warteschlange, verarbeitet die Nachricht (in diesem Fall zeigt sie den Nachrichtentext auf der Konsole an) und löscht dann die Nachricht aus der Warteschlange. Die Anwendung wiederholt diese Schritte, bis der Benutzer eine Taste auf der Tastatur eingibt.
Dieses Beispiel und das [vorherige Beispiel zum Senden von Nachrichten](SendMessage.md) können zusammen verwendet werden, um den Nachrichtenfluss in Amazon SQS zu sehen.
Die folgenden Abschnitte enthalten Auszüge aus diesem Beispiel. Der [vollständige Code für das Beispiel](#ReceiveMessage-complete-code) wird danach angezeigt und kann unverändert erstellt und ausgeführt werden.
**Topics**
+ [Empfangen Sie eine Nachricht](#ReceiveMessage-receive)
+ [Eine Nachricht löschen](#ReceiveMessage-delete)
+ [Vollständiger Code](#ReceiveMessage-complete-code)
+ [Weitere Überlegungen](#ReceiveMessage-additional)
## Empfangen Sie eine Nachricht
Das folgende Snippet empfängt eine Nachricht aus der Warteschlange, die durch die angegebene Warteschlangen-URL identifiziert wird.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#ReceiveMessage-complete-code) Snippet verwendet wird.
```
//
// Method to read a message from the given queue
// In this example, it gets one message at a time
private static async Task GetMessage(
IAmazonSQS sqsClient, string qUrl, int waitTime=0)
{
return await sqsClient.ReceiveMessageAsync(new ReceiveMessageRequest{
QueueUrl=qUrl,
MaxNumberOfMessages=MaxMessages,
WaitTimeSeconds=waitTime
// (Could also request attributes, set visibility timeout, etc.)
});
}
```
## Eine Nachricht löschen
Das folgende Snippet löscht eine Nachricht aus der Warteschlange, die durch die angegebene Warteschlangen-URL identifiziert wird.
Das Beispiel [am Ende dieses Themas zeigt, wie dieses](#ReceiveMessage-complete-code) Snippet verwendet wird.
```
//
// Method to delete a message from a queue
private static async Task DeleteMessage(
IAmazonSQS sqsClient, Message message, string qUrl)
{
Console.WriteLine($"\nDeleting message {message.MessageId} from queue...");
await sqsClient.DeleteMessageAsync(qUrl, message.ReceiptHandle);
}
```
## Vollständiger Code
Dieser Abschnitt enthält relevante Referenzen und den vollständigen Code für dieses Beispiel.
### SDK-Referenzen
NuGet Pakete:
+ [AWSSDK.SQS](https://www.nuget.org/packages/AWSSDK.SQS)
Elemente der Programmierung:
+ [Namespace Amazon.sqs](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/NSQS.html)
Klasse [Amazon SQSClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSQSClient.html)
+ [Namespace Amazon.SQS.Model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/NSQSModel.html)
Klasse [ReceiveMessageRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TReceiveMessageRequest.html)
Klasse [ReceiveMessageResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TReceiveMessageResponse.html)
### Der Code
```
using System;
using System.Threading.Tasks;
using Amazon.SQS;
using Amazon.SQS.Model;
namespace SQSReceiveMessages
{
class Program
{
private const int MaxMessages = 1;
private const int WaitTime = 2;
static async Task Main(string[] args)
{
// Do some checks on the command-line
if(args.Length == 0)
{
Console.WriteLine("\nUsage: SQSReceiveMessages queue_url");
Console.WriteLine(" queue_url - The URL of an existing SQS queue.");
return;
}
if(!args[0].StartsWith("https://sqs."))
{
Console.WriteLine("\nThe command-line argument isn't a queue URL:");
Console.WriteLine($"{args[0]}");
return;
}
// Create the Amazon SQS client
var sqsClient = new AmazonSQSClient();
// (could verify that the queue exists)
// Read messages from the queue and perform appropriate actions
Console.WriteLine($"Reading messages from queue\n {args[0]}");
Console.WriteLine("Press any key to stop. (Response might be slightly delayed.)");
do
{
var msg = await GetMessage(sqsClient, args[0], WaitTime);
if(msg.Messages.Count != 0)
{
if(ProcessMessage(msg.Messages[0]))
await DeleteMessage(sqsClient, msg.Messages[0], args[0]);
}
} while(!Console.KeyAvailable);
}
//
// Method to read a message from the given queue
// In this example, it gets one message at a time
private static async Task GetMessage(
IAmazonSQS sqsClient, string qUrl, int waitTime=0)
{
return await sqsClient.ReceiveMessageAsync(new ReceiveMessageRequest{
QueueUrl=qUrl,
MaxNumberOfMessages=MaxMessages,
WaitTimeSeconds=waitTime
// (Could also request attributes, set visibility timeout, etc.)
});
}
//
// Method to process a message
// In this example, it simply prints the message
private static bool ProcessMessage(Message message)
{
Console.WriteLine($"\nMessage body of {message.MessageId}:");
Console.WriteLine($"{message.Body}");
return true;
}
//
// Method to delete a message from a queue
private static async Task DeleteMessage(
IAmazonSQS sqsClient, Message message, string qUrl)
{
Console.WriteLine($"\nDeleting message {message.MessageId} from queue...");
await sqsClient.DeleteMessageAsync(qUrl, message.ReceiptHandle);
}
}
}
```
## Weitere Überlegungen
+ Um Long Polling anzugeben, verwendet dieses Beispiel die `WaitTimeSeconds` Eigenschaft für jeden Aufruf der `ReceiveMessageAsync` Methode.
Sie können auch lange Abfragen für alle Nachrichten in einer Warteschlange angeben, indem Sie das `ReceiveMessageWaitTimeSeconds` Attribut beim [Erstellen](CreateQueue.md) oder [Aktualisieren](UpdateSqsQueue.md) der Warteschlange verwenden.
Informationen zu kurzen Abfragen im Vergleich zu langen Abfragen finden Sie unter [Kurze und lange Abfragen](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-short-and-long-polling.html) im *Amazon Simple Queue Service* Developer Guide.
+ Während der Nachrichtenverarbeitung können Sie die Empfangsnummer verwenden, um das Timeout für die Nachrichtensichtbarkeit zu ändern. Informationen dazu finden Sie in den `ChangeMessageVisibilityAsync` Methoden der [SQSClientAmazon-Klasse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSQSClient.html).
+ Durch das `DeleteMessageAsync` bedingungslose Aufrufen der Methode wird die Nachricht unabhängig von der Einstellung für das Sichtbarkeits-Timeout aus der Warteschlange entfernt.