

Version 4 (V4) von AWS SDK für .NET wurde veröffentlicht\$1

Informationen zu wichtigen Änderungen und zur Migration Ihrer Anwendungen finden Sie im [Migrationsthema](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html).

 [https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html)

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Zugriff auf AWS Identity and Access Management (IAM) mit dem AWS SDK für .NET
<a name="iam-apis-intro"></a>

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
<a name="w2aac19c15c23c13"></a>

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/v4/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
<a name="w2aac19c15c23c15"></a>

Bevor Sie beginnen, stellen Sie sicher, dass Sie [Ihre Umgebung eingerichtet](net-dg-config.md) und [Ihr Projekt konfiguriert](configuring-the-sdk.md) haben. Lesen Sie auch die Informationen unter[Verwenden der SDK](net-dg-sdk-features.md).

## Topics
<a name="w2aac19c15c23c17"></a>

**Topics**
+ [APIs](#w2aac19c15c23c13)
+ [Voraussetzungen](#w2aac19c15c23c15)
+ [Topics](#w2aac19c15c23c17)
+ [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
<a name="iam-policies-create-json"></a>

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
<a name="iam-policies-create-json-create"></a>

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<CreatePolicyResponse> CreateManagedPolicy(
      IAmazonIdentityManagementService iamClient, string policyName, string jsonFilename)
    {
      return await iamClient.CreatePolicyAsync(new CreatePolicyRequest{
        PolicyName = policyName,
        PolicyDocument = File.ReadAllText(jsonFilename)});
    }
```

## Vollständiger Code
<a name="iam-policies-create-json-complete-code"></a>

Dieser Abschnitt enthält relevante Referenzen und den vollständigen Code für dieses Beispiel.

### SDK-Referenzen
<a name="w2aac19c15c23c21c17b5b1"></a>

NuGet Pakete:
+ [AWSSDK.IdentityManagement](https://www.nuget.org/packages/AWSSDK.IdentityManagement)

Elemente der Programmierung:
+ Namespace [Amazon. IdentityManagement](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/NIAM.html)

  Klasse [AmazonIdentityManagementServiceClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/TIAMServiceClient.html)
+ Namespace [Amazon. IdentityManagement.Modell](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/NIAMModel.html)

  Klasse [CreatePolicyRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/TCreatePolicyRequest.html)

  Klasse [CreatePolicyResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/TCreatePolicyResponse.html)

### Der Code
<a name="w2aac19c15c23c21c17b7b1"></a>

```
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<CreatePolicyResponse> 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 <policy-name> -j <json-filename>" +
        "\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<string,string> Parse(string[] args)
    {
      var parsedArgs = new Dictionary<string,string>();
      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<string,string> 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
<a name="iam-policies-create-json-additional"></a>
+ 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
<a name="iam-policies-display"></a>

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
<a name="iam-policies-display-version"></a>

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<string> 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
<a name="iam-policies-display-doc"></a>

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
<a name="iam-policies-display-complete-code"></a>

Dieser Abschnitt enthält relevante Referenzen und den vollständigen Code für dieses Beispiel.

### SDK-Referenzen
<a name="w2aac19c15c23c23c19b5b1"></a>

NuGet Pakete:
+ [AWSSDK.IdentityManagement](https://www.nuget.org/packages/AWSSDK.IdentityManagement)

Elemente der Programmierung:
+ Namespace [Amazon. IdentityManagement](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/NIAM.html)

  Klasse [AmazonIdentityManagementServiceClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/TIAMServiceClient.html)
+ Namespace [Amazon. IdentityManagement.Modell](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/NIAMModel.html)

  Klasse [GetPolicyVersionRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/TGetPolicyVersionRequest.html)

  Klasse [GetPolicyVersionResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/TGetPolicyVersionResponse.html)

  Klasse [ListPolicyVersionsRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/TListPolicyVersionsRequest.html)

  Klasse [ListPolicyVersionsResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/TListPolicyVersionsResponse.html)

  Klasse [PolicyVersion](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/TPolicyVersion.html)

### Der Code
<a name="w2aac19c15c23c23c19b7b1"></a>

```
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<string> 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
<a name="net-dg-hosm"></a>

Dieses Tutorial zeigt Ihnen, wie Sie die verwenden, um IAM-Rollen auf Amazon EC2 EC2-Instances AWS SDK für .NET zu aktivieren.

## -Übersicht
<a name="hosm-overview"></a>

Alle Anfragen an AWS müssen kryptografisch signiert werden, wobei die Anmeldeinformationen verwendet werden müssen, die von ausgestellt wurden. 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
<a name="about-hosm-tutorial"></a>

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
<a name="net-dg-hosm-sample-s3-app"></a>

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[Authentifizieren des mit AWS SDK für .NET 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
<a name="w2aac19c15c23c25c17c13b1"></a>

NuGet Pakete:
+ [AWSSDK.S3](https://www.nuget.org/packages/AWSSDK.S3)

Elemente der Programmierung:
+ [Namespace Amazon.S3](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/S3/NS3.html)

  Klasse [AmazonS3Client](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/S3/TS3Client.html)
+ Namespace [Amazon.S3.Model](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/S3/NS3Model.html)

  Klasse [GetObjectResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/S3/TGetObjectResponse.html)

### Der Code
<a name="w2aac19c15c23c25c17c15b1"></a>

```
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<GetObjectResponse> 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 <bucket-name> -t <text-object> -o <output-filename>" +
        "\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<string,string> Parse(string[] args)
    {
      var parsedArgs = new Dictionary<string,string>();
      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<string,string> 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
<a name="net-dg-hosm-create-the-role"></a>

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 Zugriffsrichtlinien anhängen** 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 bei Bedarf Stichwörter hinzu und wählen Sie dann **Weiter: Überprüfen** aus.

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
<a name="net-dg-hosm-launch-ec2-instance"></a>

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
<a name="net-dg-hosm-connect"></a>

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
<a name="net-dg-hosm-run-the-app"></a>

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
<a name="net-dg-hosm-cleanup"></a>

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.