Voraussetzungen für die Einrichtung AWS Config mit dem AWS CLI - AWS Config
Schritt 1: Einen Amazon S3 S3-Bucket erstellenSchritt 2: Ein SNS Amazon-Thema erstellenSchritt 3: Eine IAM Rolle erstellen

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.

Voraussetzungen für die Einrichtung AWS Config mit dem AWS CLI

Bevor Sie AWS mit dem einrichten AWS CLI, müssen Sie als Voraussetzungen einen Amazon S3 S3-Bucket, ein SNS Amazon-Thema und eine IAM Rolle mit angehängten Richtlinien erstellen. Anschließend können Sie AWS CLI den Bucket, das Thema und die Rolle für angeben AWS Config. Gehen Sie wie folgt vor, um Ihre Voraussetzungen für AWS Config einzurichten.

Schritt 1: Einen Amazon S3 S3-Bucket erstellen

Wenn Sie in Ihrem Konto bereits über einen Amazon-S3-Bucket verfügen und diesen verwenden möchten, überspringen Sie diesen Schritt und gehen zu Schritt 2: Ein SNS Amazon-Thema erstellen über.

So erstellen Sie einen Bucket

  1. Öffnen Sie die Amazon S3 S3-Konsole unter https://console.aws.amazon.com/s3/.

  2. Wählen Sie Bucket erstellen aus.

  3. Geben Sie im Feld Bucket-Name einen DNS -konformen Namen für Ihren Bucket ein.

    Der Bucket-Name ...:

    • überall in Amazon S3 eindeutig sein.

    • zwischen 3 und 63 Zeichen lang sein,

    • Enthält keine Großbuchstaben.

    • mit einem Kleinbuchstaben oder einer Zahl beginnen.

    Der Name eines einmal erstellter Buckets kann nicht nachträglich geändert werden. Stellen Sie sicher, dass der von Ihnen gewählte Bucket-Name unter allen in Amazon S3 vorhandenen Bucket-Namen eindeutig ist. Weitere Informationen zu Namensregeln und -konventionen für Buckets finden Sie unter Beschränkungen und Einschränkungen von Buckets im Benutzerhandbuch für Amazon Simple Storage Service.

    Wichtig

    Vermeiden Sie es, vertrauliche Informationen in den Bucket-Namen aufzunehmen. Der Bucket-Name ist in dem Punkt sichtbarURLs, auf den die Objekte im Bucket verweisen.

  4. Wählen Sie unter Region die AWS Region aus, in der sich der Bucket befinden soll.

    Wählen Sie eine Region in der Nähe aus, um Latenz und Kosten auf einem Minimum zu halten und behördliche Vorschriften zu erfüllen. In einer Region gespeicherte Objekte verbleiben so lange in der Region, bis sie explizit in eine andere Region verschoben werden. Eine Liste der Amazon S3 AWS S3-Regionen finden Sie unter AWS Service-Endpunkte in der Allgemeine Amazon Web Services-Referenz.

  5. Wählen Sie unter Bucket settings for Block Public Access (Bucket-Einstellungen für den öffentlichen Zugriff) die Einstellungen für den öffentlichen Zugriff aus, die Sie auf den Bucket anwenden möchten.

    Es wird empfohlen, alle Einstellungen aktiviert zu belassen, es sei denn, Sie wissen, dass Sie eine oder mehrere dieser Einstellungen für Ihren Anwendungsfall deaktivieren müssen, z. B. um eine öffentliche Website zu hosten. Einstellungen für den öffentlichen Zugriff, die Sie für den Bucket aktivieren, werden auch für alle Zugriffspunkte aktiviert, die Sie für den Bucket erstellen. Weitere Informationen zum Blockieren des öffentlichen Zugriffs finden Sie unter Verwenden von Amazon S3 Block Public Access im Amazon Simple Storage Service-Benutzerhandbuch.

  6. (Optional) Wenn Sie die S3-Objektsperre aktivieren möchten:

    1. Wählen Sie Fortschrittliche Einstellungen aus und lesen Sie die anschließend angezeigte Meldung.

      Wichtig

      Sie können die S3-Objektsperre für einen Bucket nur aktivieren, wenn Sie ihn erstellen. Wenn Sie die Objektsperre für den Bucket aktivieren, können Sie es später nicht mehr deaktivieren. Durch Aktivieren der Objektsperre wird auch die Versionssteuerung für den Bucket aktiviert. Nachdem Sie die Objektsperre für den Bucket aktiviert haben, müssen Sie die Objektsperreneinstellungen konfigurieren, bevor Objekte im Bucket geschützt werden. Weitere Informationen zum Konfigurieren des Schutzes für Objekte finden Sie unter Konfigurieren der S3 Object Lock mit der Amazon-S3-Konsole.

    2. Wenn Sie die Objektsperre aktivieren möchten, geben Sie in das Textfeld enable (Aktivieren) ein und wählen Sie Confirm (Bestätigen) aus.

    Weitere Informationen zur S3-Objektsperrenfunktion finden Sie unter Sperren von Objekten mit der Amazon S3-Objektsperre im Amazon Simple Storage Service-Benutzerhandbuch.

  7. Wählen Sie Bucket erstellen aus.

Wenn Sie den verwenden, AWS SDKs um einen Bucket zu erstellen, müssen Sie einen Client erstellen und dann den Client verwenden, um eine Anfrage zum Erstellen eines Buckets zu senden. Als bewährte Methode sollten Sie Ihren Client und Ihren Bucket in derselben AWS-Region erstellen. Wenn Sie beim Erstellen eines Clients oder Buckets keine Region angeben, verwendet Amazon S3 die Standardregion USA Ost (Nord-Virginia).

Um einen Client für den Zugriff auf einen Dual-Stack-Endpunkt zu erstellen, müssen Sie einen AWS-Region angeben. Weitere Informationen finden Sie unter Dual-Stack-Endpunkte von Amazon S3. Eine Liste der verfügbaren AWS-Regionen Regionen und Endpunkte finden Sie unter Regionen und Endpunkte in der. Allgemeine AWS-Referenz

Wenn Sie einen Client erstellen, wird die Region dem regionsspezifischen Endpunkt zugeordnet. Der Client verwendet diesen Endpunkt für die Kommunikation mit Amazon S3: s3.<region>.amazonaws.com. Wenn Ihre Region nach dem 20. März 2019 gestartet wurde, müssen sich Ihr Client und Ihr Bucket in derselben Region befinden. Sie können jedoch einen Client in der Region USA Ost (Nord-Virginia) verwenden, um einen Bucket in einer beliebigen Region zu erstellen, die vor dem 20. März 2019 gestartet wurde. Weitere Informationen finden Sie unter Legacy-Endpunkte.

Mit diesen AWS SDK Codebeispielen werden die folgenden Aufgaben ausgeführt:

  • Erstellen Sie einen Client, indem Sie explizit eine AWS-Region angeben – Im Beispiel verwendet der Client den Endpunkt s3.us-west-2.amazonaws.com, um mit Amazon S3 zu kommunizieren. Sie können eine beliebige AWS-Region angeben. Eine Liste von AWS-Regionen finden Sie unter Regionen und Endpunkte in der AWS allgemeinen Referenz.

  • Senden einer Bucket-Erstellungs-Anfrage durch Angabe eines Bucket-Namens – Der Client sendet eine Anfrage an Amazon S3, um den Bucket in der Region zu erstellen, in der Sie einen Client erstellt haben.

  • Abrufen von Informationen zum Standort des Buckets – Amazon S3 speichert Informationen zum Standort des Buckets in der Subressource location (Standort), die dem Bucket zugeordnet ist.

In den folgenden Codebeispielen wird die Verwendung CreateBucket veranschaulicht.

.NET
AWS SDK for .NET
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 


        /// <summary>
        /// Shows how to create a new Amazon S3 bucket.
        /// </summary>
        /// <param name="client">An initialized Amazon S3 client object.</param>
        /// <param name="bucketName">The name of the bucket to create.</param>
        /// <returns>A boolean value representing the success or failure of
        /// the bucket creation process.</returns>
        public static async Task<bool> CreateBucketAsync(IAmazonS3 client, string bucketName)
        {
            try
            {
                var request = new PutBucketRequest
                {
                    BucketName = bucketName,
                    UseClientRegion = true,
                };

                var response = await client.PutBucketAsync(request);
                return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
            }
            catch (AmazonS3Exception ex)
            {
                Console.WriteLine($"Error creating bucket: '{ex.Message}'");
                return false;
            }
        }

Erstellen Sie einen Bucket mit aktivierter Objektsperre.

    /// <summary>
    /// Create a new Amazon S3 bucket with object lock actions.
    /// </summary>
    /// <param name="bucketName">The name of the bucket to create.</param>
    /// <param name="enableObjectLock">True to enable object lock on the bucket.</param>
    /// <returns>True if successful.</returns>
    public async Task<bool> CreateBucketWithObjectLock(string bucketName, bool enableObjectLock)
    {
        Console.WriteLine($"\tCreating bucket {bucketName} with object lock {enableObjectLock}.");
        try
        {
            var request = new PutBucketRequest
            {
                BucketName = bucketName,
                UseClientRegion = true,
                ObjectLockEnabledForBucket = enableObjectLock,
            };

            var response = await _amazonS3.PutBucketAsync(request);

            return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
        }
        catch (AmazonS3Exception ex)
        {
            Console.WriteLine($"Error creating bucket: '{ex.Message}'");
            return false;
        }
    }

  • APIEinzelheiten finden Sie CreateBucketunter AWS SDK for .NET APIReferenz.

Bash
AWS CLI mit Bash-Skript
Anmerkung

Es gibt noch mehr dazu. GitHub Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

###############################################################################
# function iecho
#
# This function enables the script to display the specified text only if
# the global variable $VERBOSE is set to true.
###############################################################################
function iecho() {
  if [[ $VERBOSE == true ]]; then
    echo "$@"
  fi
}

###############################################################################
# function errecho
#
# This function outputs everything sent to it to STDERR (standard error output).
###############################################################################
function errecho() {
  printf "%s\n" "$*" 1>&2
}

###############################################################################
# function create-bucket
#
# This function creates the specified bucket in the specified AWS Region, unless
# it already exists.
#
# Parameters:
#       -b bucket_name  -- The name of the bucket to create.
#       -r region_code  -- The code for an AWS Region in which to
#                          create the bucket.
#
# Returns:
#       The URL of the bucket that was created.
#     And:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function create_bucket() {
  local bucket_name region_code response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function create_bucket"
    echo "Creates an Amazon S3 bucket. You must supply a bucket name:"
    echo "  -b bucket_name    The name of the bucket. It must be globally unique."
    echo "  [-r region_code]    The code for an AWS Region in which the bucket is created."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "b:r:h" option; do
    case "${option}" in
      b) bucket_name="${OPTARG}" ;;
      r) region_code="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done

  if [[ -z "$bucket_name" ]]; then
    errecho "ERROR: You must provide a bucket name with the -b parameter."
    usage
    return 1
  fi

  local bucket_config_arg
  # A location constraint for "us-east-1" returns an error.
  if [[ -n "$region_code" ]] && [[ "$region_code" != "us-east-1" ]]; then
    bucket_config_arg="--create-bucket-configuration LocationConstraint=$region_code"
  fi

  iecho "Parameters:\n"
  iecho "    Bucket name:   $bucket_name"
  iecho "    Region code:   $region_code"
  iecho ""

  # If the bucket already exists, we don't want to try to create it.
  if (bucket_exists "$bucket_name"); then
    errecho "ERROR: A bucket with that name already exists. Try again."
    return 1
  fi

  # shellcheck disable=SC2086
  response=$(aws s3api create-bucket \
    --bucket "$bucket_name" \
    $bucket_config_arg)

  # shellcheck disable=SC2181
  if [[ ${?} -ne 0 ]]; then
    errecho "ERROR: AWS reports create-bucket operation failed.\n$response"
    return 1
  fi
}

  • APIEinzelheiten finden Sie CreateBucketin der AWS CLI Befehlsreferenz.

C++
SDKfür C++
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

bool AwsDoc::S3::createBucket(const Aws::String &bucketName,
                              const Aws::S3::S3ClientConfiguration &clientConfig) {
    Aws::S3::S3Client client(clientConfig);
    Aws::S3::Model::CreateBucketRequest request;
    request.SetBucket(bucketName);

    if (clientConfig.region != "us-east-1") {
        Aws::S3::Model::CreateBucketConfiguration createBucketConfig;
        createBucketConfig.SetLocationConstraint(
                Aws::S3::Model::BucketLocationConstraintMapper::GetBucketLocationConstraintForName(
                        clientConfig.region));
        request.SetCreateBucketConfiguration(createBucketConfig);
    }

    Aws::S3::Model::CreateBucketOutcome outcome = client.CreateBucket(request);
    if (!outcome.IsSuccess()) {
        auto err = outcome.GetError();
        std::cerr << "Error: createBucket: " <<
                  err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
    } else {
        std::cout << "Created bucket " << bucketName <<
                  " in the specified AWS Region." << std::endl;
    }

    return outcome.IsSuccess();
}

  • APIEinzelheiten finden Sie CreateBucketunter AWS SDK for C++ APIReferenz.

CLI
AWS CLI

Beispiel 1: Um einen Bucket zu erstellen

Im folgenden create-bucket Beispiel wird ein Bucket mit dem Namen erstelltmy-bucket:

aws s3api create-bucket \
    --bucket my-bucket \
    --region us-east-1

Ausgabe:

{
    "Location": "/my-bucket"
}

Weitere Informationen finden Sie unter Bucket erstellen im Amazon S3 S3-Benutzerhandbuch.

Beispiel 2: Um einen Bucket zu erstellen, bei dem der Besitzer erzwungen wird

Im folgenden create-bucket Beispiel wird ein Bucket mit dem Namen erstellt, der my-bucket die Einstellung Bucket Owner erforced für S3 Object Ownership verwendet.

aws s3api create-bucket \
    --bucket my-bucket \
    --region us-east-1 \
    --object-ownership BucketOwnerEnforced

Ausgabe:

{
    "Location": "/my-bucket"
}

Weitere Informationen finden Sie unter Kontrolle des Besitzes von Objekten und Deaktivierung ACLs im Amazon S3 S3-Benutzerhandbuch.

Beispiel 3: Um einen Bucket außerhalb der Region ``us-east-1`` zu erstellen

Im folgenden create-bucket Beispiel wird ein Bucket mit dem Namen der Region erstellt. my-bucket eu-west-1 Für Regionen außerhalb von us-east-1 müssen die entsprechenden LocationConstraint Felder angegeben werden, um den Bucket in der gewünschten Region zu erstellen.

aws s3api create-bucket \
    --bucket my-bucket \
    --region eu-west-1 \
    --create-bucket-configuration LocationConstraint=eu-west-1

Ausgabe:

{
    "Location": "http://my-bucket.s3.amazonaws.com/"
}

Weitere Informationen finden Sie unter Bucket erstellen im Amazon S3 S3-Benutzerhandbuch.

  • APIEinzelheiten finden Sie CreateBucketunter AWS CLI Befehlsreferenz.

Go
SDKfür Go V2
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen.

Erstellen Sie einen Bucket mit Standardkonfiguration.


// BucketBasics encapsulates the Amazon Simple Storage Service (Amazon S3) actions
// used in the examples.
// It contains S3Client, an Amazon S3 service client that is used to perform bucket
// and object actions.
type BucketBasics struct {
	S3Client *s3.Client
}



// CreateBucket creates a bucket with the specified name in the specified Region.
func (basics BucketBasics) CreateBucket(ctx context.Context, name string, region string) error {
	_, err := basics.S3Client.CreateBucket(ctx, &s3.CreateBucketInput{
		Bucket: aws.String(name),
		CreateBucketConfiguration: &types.CreateBucketConfiguration{
			LocationConstraint: types.BucketLocationConstraint(region),
		},
	})
	if err != nil {
		log.Printf("Couldn't create bucket %v in Region %v. Here's why: %v\n",
			name, region, err)
	}
	return err
}

Erstellen Sie einen Bucket mit Objektsperre und warten Sie, bis er existiert.


// S3Actions wraps S3 service actions.
type S3Actions struct {
	S3Client  *s3.Client
	S3Manager *manager.Uploader
}



// CreateBucketWithLock creates a new S3 bucket with optional object locking enabled
// and waits for the bucket to exist before returning.
func (actor S3Actions) CreateBucketWithLock(ctx context.Context, bucket string, region string, enableObjectLock bool) (string, error) {
	input := &s3.CreateBucketInput{
		Bucket: aws.String(bucket),
		CreateBucketConfiguration: &types.CreateBucketConfiguration{
			LocationConstraint: types.BucketLocationConstraint(region),
		},
	}

	if enableObjectLock {
		input.ObjectLockEnabledForBucket = aws.Bool(true)
	}

	_, err := actor.S3Client.CreateBucket(ctx, input)
	if err != nil {
		var owned *types.BucketAlreadyOwnedByYou
		var exists *types.BucketAlreadyExists
		if errors.As(err, &owned) {
			log.Printf("You already own bucket %s.\n", bucket)
			err = owned
		} else if errors.As(err, &exists) {
			log.Printf("Bucket %s already exists.\n", bucket)
			err = exists
		}
	} else {
		err = s3.NewBucketExistsWaiter(actor.S3Client).Wait(
			ctx, &s3.HeadBucketInput{Bucket: aws.String(bucket)}, time.Minute)
		if err != nil {
			log.Printf("Failed attempt to wait for bucket %s to exist.\n", bucket)
		}
	}

	return bucket, err
}

  • APIEinzelheiten finden Sie CreateBucketunter AWS SDK for Go APIReferenz.

Java
SDKfür Java 2.x
Anmerkung

Es gibt noch mehr dazu. GitHub Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen.

Erstellen Sie einen Bucket.


    /**
     * Creates an S3 bucket asynchronously.
     *
     * @param bucketName the name of the S3 bucket to create
     * @return a {@link CompletableFuture} that completes when the bucket is created and ready
     * @throws RuntimeException if there is a failure while creating the bucket
     */
    public CompletableFuture<Void> createBucketAsync(String bucketName) {
        CreateBucketRequest bucketRequest = CreateBucketRequest.builder()
            .bucket(bucketName)
            .build();

        CompletableFuture<CreateBucketResponse> response = getAsyncClient().createBucket(bucketRequest);
        return response.thenCompose(resp -> {
            S3AsyncWaiter s3Waiter = getAsyncClient().waiter();
            HeadBucketRequest bucketRequestWait = HeadBucketRequest.builder()
                .bucket(bucketName)
                .build();

            CompletableFuture<WaiterResponse<HeadBucketResponse>> waiterResponseFuture =
                s3Waiter.waitUntilBucketExists(bucketRequestWait);
            return waiterResponseFuture.thenAccept(waiterResponse -> {
                waiterResponse.matched().response().ifPresent(headBucketResponse -> {
                    logger.info(bucketName + " is ready");
                });
            });
        }).whenComplete((resp, ex) -> {
            if (ex != null) {
                throw new RuntimeException("Failed to create bucket", ex);
            }
        });
    }

Erstellen Sie einen Bucket mit aktivierter Objektsperre.

    // Create a new Amazon S3 bucket with object lock options.
    public void createBucketWithLockOptions(boolean enableObjectLock, String bucketName) {
        S3Waiter s3Waiter = getClient().waiter();
        CreateBucketRequest bucketRequest = CreateBucketRequest.builder()
            .bucket(bucketName)
            .objectLockEnabledForBucket(enableObjectLock)
            .build();

        getClient().createBucket(bucketRequest);
        HeadBucketRequest bucketRequestWait = HeadBucketRequest.builder()
            .bucket(bucketName)
            .build();

        // Wait until the bucket is created and print out the response.
        s3Waiter.waitUntilBucketExists(bucketRequestWait);
        System.out.println(bucketName + " is ready");
    }

  • APIEinzelheiten finden Sie CreateBucketunter AWS SDK for Java 2.x APIReferenz.

JavaScript
SDKfür JavaScript (v3)
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen.

Erstellen Sie den Bucket.

import {
  BucketAlreadyExists,
  BucketAlreadyOwnedByYou,
  CreateBucketCommand,
  S3Client,
  waitUntilBucketExists,
} from "@aws-sdk/client-s3";

/**
 * Create an Amazon S3 bucket.
 * @param {{ bucketName: string }} config
 */
export const main = async ({ bucketName }) => {
  const client = new S3Client({});

  try {
    const { Location } = await client.send(
      new CreateBucketCommand({
        // The name of the bucket. Bucket names are unique and have several other constraints.
        // See https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html
        Bucket: bucketName,
      }),
    );
    await waitUntilBucketExists({ client }, { Bucket: bucketName });
    console.log(`Bucket created with location ${Location}`);
  } catch (caught) {
    if (caught instanceof BucketAlreadyExists) {
      console.error(
        `The bucket "${bucketName}" already exists in another AWS account. Bucket names must be globally unique.`,
      );
    }
    // WARNING: If you try to create a bucket in the North Virginia region,
    // and you already own a bucket in that region with the same name, this
    // error will not be thrown. Instead, the call will return successfully
    // and the ACL on that bucket will be reset.
    else if (caught instanceof BucketAlreadyOwnedByYou) {
      console.error(
        `The bucket "${bucketName}" already exists in this AWS account.`,
      );
    } else {
      throw caught;
    }
  }
};
Kotlin
SDKfür Kotlin
Anmerkung

Es gibt noch mehr dazu. GitHub Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

suspend fun createNewBucket(bucketName: String) {
    val request =
        CreateBucketRequest {
            bucket = bucketName
        }

    S3Client { region = "us-east-1" }.use { s3 ->
        s3.createBucket(request)
        println("$bucketName is ready")
    }
}

  • APIEinzelheiten finden Sie CreateBucketin der AWS SDKAPIKotlin-Referenz.

PHP
SDK für PHP
Anmerkung

Es gibt noch mehr dazu. GitHub Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen.

Erstellen Sie einen Bucket.

        $s3client = new Aws\S3\S3Client(['region' => 'us-west-2']);

        try {
            $this->s3client->createBucket([
                'Bucket' => $this->bucketName,
                'CreateBucketConfiguration' => ['LocationConstraint' => $region],
            ]);
            echo "Created bucket named: $this->bucketName \n";
        } catch (Exception $exception) {
            echo "Failed to create bucket $this->bucketName with error: " . $exception->getMessage();
            exit("Please fix error with bucket creation before continuing.");
        }

  • APIEinzelheiten finden Sie CreateBucketunter AWS SDK for PHP APIReferenz.

Python
SDKfür Python (Boto3)
Anmerkung

Es gibt noch mehr dazu. GitHub Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen.

Erstellen Sie einen Bucket mit Standardeinstellungen.

class BucketWrapper:
    """Encapsulates S3 bucket actions."""

    def __init__(self, bucket):
        """
        :param bucket: A Boto3 Bucket resource. This is a high-level resource in Boto3
                       that wraps bucket actions in a class-like structure.
        """
        self.bucket = bucket
        self.name = bucket.name


    def create(self, region_override=None):
        """
        Create an Amazon S3 bucket in the default Region for the account or in the
        specified Region.

        :param region_override: The Region in which to create the bucket. If this is
                                not specified, the Region configured in your shared
                                credentials is used.
        """
        if region_override is not None:
            region = region_override
        else:
            region = self.bucket.meta.client.meta.region_name
        try:
            self.bucket.create(CreateBucketConfiguration={"LocationConstraint": region})

            self.bucket.wait_until_exists()
            logger.info("Created bucket '%s' in region=%s", self.bucket.name, region)
        except ClientError as error:
            logger.exception(
                "Couldn't create bucket named '%s' in region=%s.",
                self.bucket.name,
                region,
            )
            raise error

Erstellen Sie einen versionierten Bucket mit einer Lebenszyklus-Konfiguration.

def create_versioned_bucket(bucket_name, prefix):
    """
    Creates an Amazon S3 bucket, enables it for versioning, and configures a lifecycle
    that expires noncurrent object versions after 7 days.

    Adding a lifecycle configuration to a versioned bucket is a best practice.
    It helps prevent objects in the bucket from accumulating a large number of
    noncurrent versions, which can slow down request performance.

    Usage is shown in the usage_demo_single_object function at the end of this module.

    :param bucket_name: The name of the bucket to create.
    :param prefix: Identifies which objects are automatically expired under the
                   configured lifecycle rules.
    :return: The newly created bucket.
    """
    try:
        bucket = s3.create_bucket(
            Bucket=bucket_name,
            CreateBucketConfiguration={
                "LocationConstraint": s3.meta.client.meta.region_name
            },
        )
        logger.info("Created bucket %s.", bucket.name)
    except ClientError as error:
        if error.response["Error"]["Code"] == "BucketAlreadyOwnedByYou":
            logger.warning("Bucket %s already exists! Using it.", bucket_name)
            bucket = s3.Bucket(bucket_name)
        else:
            logger.exception("Couldn't create bucket %s.", bucket_name)
            raise

    try:
        bucket.Versioning().enable()
        logger.info("Enabled versioning on bucket %s.", bucket.name)
    except ClientError:
        logger.exception("Couldn't enable versioning on bucket %s.", bucket.name)
        raise

    try:
        expiration = 7
        bucket.LifecycleConfiguration().put(
            LifecycleConfiguration={
                "Rules": [
                    {
                        "Status": "Enabled",
                        "Prefix": prefix,
                        "NoncurrentVersionExpiration": {"NoncurrentDays": expiration},
                    }
                ]
            }
        )
        logger.info(
            "Configured lifecycle to expire noncurrent versions after %s days "
            "on bucket %s.",
            expiration,
            bucket.name,
        )
    except ClientError as error:
        logger.warning(
            "Couldn't configure lifecycle on bucket %s because %s. "
            "Continuing anyway.",
            bucket.name,
            error,
        )

    return bucket

  • APIEinzelheiten finden Sie unter CreateBucketPython (Boto3) API -Referenz.AWS SDK

Ruby
SDKfür Ruby
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

require 'aws-sdk-s3'

# Wraps Amazon S3 bucket actions.
class BucketCreateWrapper
  attr_reader :bucket

  # @param bucket [Aws::S3::Bucket] An Amazon S3 bucket initialized with a name. This is a client-side object until
  #                                 create is called.
  def initialize(bucket)
    @bucket = bucket
  end

  # Creates an Amazon S3 bucket in the specified AWS Region.
  #
  # @param region [String] The Region where the bucket is created.
  # @return [Boolean] True when the bucket is created; otherwise, false.
  def create?(region)
    @bucket.create(create_bucket_configuration: { location_constraint: region })
    true
  rescue Aws::Errors::ServiceError => e
    puts "Couldn't create bucket. Here's why: #{e.message}"
    false
  end

  # Gets the Region where the bucket is located.
  #
  # @return [String] The location of the bucket.
  def location
    if @bucket.nil?
      'None. You must create a bucket before you can get its location!'
    else
      @bucket.client.get_bucket_location(bucket: @bucket.name).location_constraint
    end
  rescue Aws::Errors::ServiceError => e
    "Couldn't get the location of #{@bucket.name}. Here's why: #{e.message}"
  end
end

# Example usage:
def run_demo
<<<<<<< HEAD
  region = "us-west-2"
  wrapper = BucketCreateWrapper.new(Aws::S3::Bucket.new("amzn-s3-demo-bucket-#{Random.uuid}"))
=======
  region = 'us-west-2'
  wrapper = BucketCreateWrapper.new(Aws::S3::Bucket.new("doc-example-bucket-#{Random.uuid}"))
>>>>>>> 999c6133e (fixes)
  return unless wrapper.create?(region)

  puts "Created bucket #{wrapper.bucket.name}."
  puts "Your bucket's region is: #{wrapper.location}"
end

run_demo if $PROGRAM_NAME == __FILE__

  • APIEinzelheiten finden Sie CreateBucketunter AWS SDK for Ruby APIReferenz.

Rust
SDKfür Rust
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

pub async fn create_bucket(
    client: &aws_sdk_s3::Client,
    bucket_name: &str,
    region: &aws_config::Region,
) -> Result<Option<aws_sdk_s3::operation::create_bucket::CreateBucketOutput>, S3ExampleError> {
    let constraint = aws_sdk_s3::types::BucketLocationConstraint::from(region.to_string().as_str());
    let cfg = aws_sdk_s3::types::CreateBucketConfiguration::builder()
        .location_constraint(constraint)
        .build();
    let create = client
        .create_bucket()
        .create_bucket_configuration(cfg)
        .bucket(bucket_name)
        .send()
        .await;

    // BucketAlreadyExists and BucketAlreadyOwnedByYou are not problems for this task.
    create.map(Some).or_else(|err| {
        if err
            .as_service_error()
            .map(|se| se.is_bucket_already_exists() || se.is_bucket_already_owned_by_you())
            == Some(true)
        {
            Ok(None)
        } else {
            Err(S3ExampleError::from(err))
        }
    })
}

  • APIEinzelheiten finden Sie CreateBucketin der AWS SDKAPIRust-Referenz.

SAP ABAP
SDKfür SAP ABAP
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

    TRY.
        lo_s3->createbucket(
            iv_bucket = iv_bucket_name
        ).
        MESSAGE 'S3 bucket created.' TYPE 'I'.
      CATCH /aws1/cx_s3_bucketalrdyexists.
        MESSAGE 'Bucket name already exists.' TYPE 'E'.
      CATCH /aws1/cx_s3_bktalrdyownedbyyou.
        MESSAGE 'Bucket already exists and is owned by you.' TYPE 'E'.
    ENDTRY.

  • APIEinzelheiten finden Sie CreateBucketunter AWS SDKSAPABAPAPIals Referenz.

Swift
SDKfür Swift
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

import AWSS3

    public func createBucket(name: String) async throws {
        var input = CreateBucketInput(
            bucket: name
        )
        
        // For regions other than "us-east-1", you must set the locationConstraint in the createBucketConfiguration.
        // For more information, see LocationConstraint in the S3 API guide.
        // https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateBucket.html#API_CreateBucket_RequestBody
        if let region = configuration.region {
            if region != "us-east-1" {
                input.createBucketConfiguration = S3ClientTypes.CreateBucketConfiguration(locationConstraint: S3ClientTypes.BucketLocationConstraint(rawValue: region))
            }
        }

        do {
            _ = try await client.createBucket(input: input)
        }
        catch let error as BucketAlreadyOwnedByYou {
            print("The bucket '\(name)' already exists and is owned by you. You may wish to ignore this exception.")
            throw error
        }
        catch {
            print("ERROR: ", dump(error, name: "Creating a bucket"))
            throw error
        }
    }

  • APIEinzelheiten finden Sie CreateBucketin der AWS SDKAPISwift-Referenz.

Anmerkung

Sie können auch den Amazon-S3-Bucket eines anderen Kontos verwenden. Allerdings müssen Sie ggf. eine Richtlinie für den Bucket erstellen, die AWS Config Zugriffsberechtigungen erteilt. Weitere Informationen zum Erteilen von Berechtigungen für einen Amazon-S3-Bucket finden Sie unter Berechtigungen für den Amazon S3 S3-Bucket für den AWS Config Lieferkanal. Rufen Sie anschließend Schritt 2: Ein SNS Amazon-Thema erstellen auf.

Schritt 2: Ein SNS Amazon-Thema erstellen

Wenn Sie bereits ein SNS Amazon-Thema in Ihrem Konto haben und es verwenden möchten, überspringen Sie diesen Schritt und gehen Sie zuSchritt 3: Eine IAM Rolle erstellen.

Um ein SNS Amazon-Thema zu erstellen

  1. Öffnen Sie die SNS Amazon-Konsole unter https://console.aws.amazon.com/sns/v3/home.

  2. Führen Sie eine der folgenden Aktionen aus:

    • Wenn noch nie zuvor Themen unter Ihrem AWS-Konto erstellt wurden, lesen Sie die Beschreibung von Amazon SNS auf der Startseite.

    • Wenn AWS-Konto zuvor Themen unter Ihrem Konto erstellt wurden, wählen Sie im Navigationsbereich die Option Themen aus.

  3. Klicken Sie auf der Seite Themen auf Create New Topic.

  4. Führen Sie auf der Seite Create subscription (Abonnement erstellen) im Abschnitt Details die folgenden Schritte aus:

    1. Wählen Sie unter Typ einen Thementyp aus (Standard oder FIFO).

    2. Geben Sie den Namen des neuen Themas ein. Fügen Sie für ein FIFOThema .fifo am Ende des Namens hinzu.

    3. (Optional) Geben Sie einen Anzeigenamen für Ihr Thema ein.

    4. (Optional) Für ein FIFO Thema können Sie die inhaltsbasierte Nachrichtendeduplizierung wählen, um die standardmäßige Nachrichtendeduplizierung zu aktivieren. Weitere Informationen finden Sie unter Themen zur Nachrichtendeduplizierung. FIFO

  5. (Optional) Erweitern Sie den Abschnitt Encryption (Verschlüsselung) und gehen Sie wie folgt vor. Weitere Informationen finden Sie unter Verschlüsselung im Ruhezustand.

    1. Wählen Sie Enable encryption (Verschlüsselung aktivieren) aus.

    2. Geben Sie den Kundenhauptschlüssel () CMK an. Weitere Informationen finden Sie unter Schlüsselbegriffe.

      Für jeden CMK Typ CMKARNwerden Beschreibung, Konto und angezeigt.

      Wichtig

      Wenn Sie nicht der Besitzer von sind oder wenn Sie sich mit einem Konto anmelden, das nicht über die kms:DescribeKey Berechtigungen kms:ListAliases und verfügt, können Sie CMK auf der SNS Amazon-Konsole keine Informationen über anzeigen. CMK

      Bitten Sie den Besitzer von, Ihnen diese Berechtigungen CMK zu gewähren. Weitere Informationen finden Sie in der Referenz „AWS KMS APIBerechtigungen: Aktionen und Ressourcen“ im AWS Key Management Service Entwicklerhandbuch.

      • Der Alias „ AWS Verwaltet CMK für Amazon“ SNS (Standard) ist standardmäßig ausgewählt.

        Anmerkung

        Beachten Sie Folgendes:

        • Wenn Sie das erste Mal verwenden AWS Management Console , um das CMK für Amazon AWS verwaltete Objekt SNS für ein Thema anzugeben, AWS KMS wird das CMK für Amazon AWS verwaltete Objekt erstelltSNS.

        • Alternativ können Sie, wenn Sie die Publish Aktion zum ersten Mal für ein Thema verwenden, für das SSE aktiviert ist, die Aktion „ AWS Verwaltet CMK für Amazon“ AWS KMS erstelltSNS.

      • Um einen benutzerdefinierten Schlüssel CMK aus Ihrem zu verwenden AWS-Konto, wählen Sie das Feld Kundenhauptschlüssel (CMK) und wählen Sie dann den benutzerdefinierten Schlüssel CMK aus der Liste aus.

        Anmerkung

        Anweisungen zur Erstellung benutzerdefinierter CMKs Schlüssel finden Sie unter Creating Keys im AWS Key Management Service Developer Guide

      • Um einen benutzerdefinierten Code CMK ARN aus Ihrem AWS-Konto oder einem anderen AWS Konto zu verwenden, geben Sie ihn in das Feld Kundenhauptschlüssel (CMK) ein.

  6. (Optional) Standardmäßig kann nur der Eigentümer des Themas das Thema abonnieren oder Veröffentlichungen dazu vornehmen. Um zusätzliche Zugriffsberechtigungen zu konfigurieren, erweitern Sie den Abschnitt Access policy (Zugriffsrichtlinie). Weitere Informationen finden Sie unter Identitäts- und Zugriffsmanagement in Amazon SNS und Beispielfälle für Amazon SNS Access Control.

    Anmerkung

    Wenn Sie ein Thema mit der Konsole erstellen, verwendet die Standardrichtlinie den Bedingungsschlüssel aws:SourceOwner. Dieser Schlüssel ist ähnlich wie aws:SourceAccount.

  7. (Optional) Um zu konfigurieren, wie Amazon SNS fehlgeschlagene Nachrichtenzustellungsversuche wiederholt, erweitern Sie den Abschnitt Richtlinie für wiederholte Zustellungen (HTTP/S). Weitere Informationen finden Sie unter Wiederholungsversuche bei der SNS Amazon-Nachrichtenzustellung.

  8. (Optional) Um zu konfigurieren, wie Amazon die Zustellung von Nachrichten SNS protokolliert CloudWatch, erweitern Sie den Abschnitt Versandstatusprotokollierung. Weitere Informationen finden Sie unter Status der SNS Amazon-Nachrichtenzustellung.

  9. (Optional) Wenn Sie Metadaten-Tags zum Thema hinzufügen, erweitern Sie den Tag-Abschnitt, geben Sie einen Schlüssel und einen Wert ein (optional), und wählen Sie Tag hinzufügen aus. Weitere Informationen finden Sie unter SNSAmazon-Themen-Tagging.

  10. Wählen Sie Thema erstellen aus.

    Das Thema wird erstellt und das MyTopicDie Seite wird angezeigt.

    Der Name des Themas ARN, (optional) der Anzeigename und die AWS Konto-ID des Themenbesitzers werden im Abschnitt Details angezeigt.

  11. Kopieren Sie das Thema ARN in die Zwischenablage, zum Beispiel:

    arn:aws:sns:us-east-2:123456789012:MyTopic
Um eine E-Mail-Adresse für das SNS Amazon-Thema zu abonnieren

  1. Öffnen Sie die SNS Amazon-Konsole unter https://console.aws.amazon.com/sns/v3/home.

  2. Wählen Sie im linken Navigationsbereich Subscriptions (Abonnements).

  3. Wählen Sie auf der Seite Subscriptions (Abonnements) die Option Create subscription (Abonnement erstellen)aus.

  4. Führen Sie auf der Seite Create subscription (Abonnement erstellen) im Abschnitt Details die folgenden Schritte aus:

    1. Wählen Sie als Thema ARN den Amazon-Ressourcennamen (ARN) eines Themas aus.

    2. Für Protocol wählen Sie einen Endpunkttypen. Folgende Endpunkttypen stehen zur Verfügung:

    3. Geben Sie für Endpoint den Endpunktwert ein, z. B. eine E-Mail-Adresse oder die ARN einer SQS Amazon-Warteschlange.

    4. Nur Firehose-Endpunkte: Geben Sie für die ARNAbonnementrolle die IAM Rolle anARN, die Sie für das Schreiben in Firehose-Lieferdatenströme erstellt haben. Weitere Informationen finden Sie unter Voraussetzungen für das Abonnieren von Firehose-Lieferstreams für SNS Amazon-Themen.

    5. (Optional) Für Firehose-SQS, Amazon- und HTTP /S-Endpunkte können Sie auch die Zustellung von Rohnachrichten aktivieren. Weitere Informationen finden Sie unter Amazon SNS Raw Message Delivery.

    6. (Optional) Um eine Filterrichtlinie zu konfigurieren, erweitern Sie den Abschnitt Abonnement-Filterrichtlinie. Weitere Informationen finden Sie unter SNSAmazon-Abonnementfilterrichtlinien.

    7. (Optional) Um eine Warteschlange für unzustellbare Nachrichten für das Abonnement zu konfigurieren, erweitern Sie den Abschnitt Redrive-Richtlinie (Warteschlange für unzustellbare Nachrichten). Weitere Informationen finden Sie unter Amazon-Warteschlangen für SNS unzustellbare Briefe (). DLQs

    8. Wählen Sie Create subscription (Abonnement erstellen) aus.

      Die Konsole erstellt das Abonnement und öffnet die Seite Details des Abonnements.

Um eine zu verwenden AWS SDK, müssen Sie sie mit Ihren Anmeldeinformationen konfigurieren. Weitere Informationen finden Sie unter The shared config and credentials files im Referenzhandbuch AWS SDKsund im Tools-Referenzhandbuch.

Die folgenden Codebeispiele zeigen die VerwendungCreateTopic.

.NET
AWS SDK for .NET
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen.

Erstellen Sie ein Thema mit einem bestimmten Namen.

    using System;
    using System.Threading.Tasks;
    using Amazon.SimpleNotificationService;
    using Amazon.SimpleNotificationService.Model;

    /// <summary>
    /// This example shows how to use Amazon Simple Notification Service
    /// (Amazon SNS) to add a new Amazon SNS topic.
    /// </summary>
    public class CreateSNSTopic
    {
        public static async Task Main()
        {
            string topicName = "ExampleSNSTopic";

            IAmazonSimpleNotificationService client = new AmazonSimpleNotificationServiceClient();

            var topicArn = await CreateSNSTopicAsync(client, topicName);
            Console.WriteLine($"New topic ARN: {topicArn}");
        }

        /// <summary>
        /// Creates a new SNS topic using the supplied topic name.
        /// </summary>
        /// <param name="client">The initialized SNS client object used to
        /// create the new topic.</param>
        /// <param name="topicName">A string representing the topic name.</param>
        /// <returns>The Amazon Resource Name (ARN) of the created topic.</returns>
        public static async Task<string> CreateSNSTopicAsync(IAmazonSimpleNotificationService client, string topicName)
        {
            var request = new CreateTopicRequest
            {
                Name = topicName,
            };

            var response = await client.CreateTopicAsync(request);

            return response.TopicArn;
        }
    }

Erstellen Sie ein neues Thema mit einem Namen und spezifischen Attributen FIFO sowie Deduplizierungsattributen.

    /// <summary>
    /// Create a new topic with a name and specific FIFO and de-duplication attributes.
    /// </summary>
    /// <param name="topicName">The name for the topic.</param>
    /// <param name="useFifoTopic">True to use a FIFO topic.</param>
    /// <param name="useContentBasedDeduplication">True to use content-based de-duplication.</param>
    /// <returns>The ARN of the new topic.</returns>
    public async Task<string> CreateTopicWithName(string topicName, bool useFifoTopic, bool useContentBasedDeduplication)
    {
        var createTopicRequest = new CreateTopicRequest()
        {
            Name = topicName,
        };

        if (useFifoTopic)
        {
            // Update the name if it is not correct for a FIFO topic.
            if (!topicName.EndsWith(".fifo"))
            {
                createTopicRequest.Name = topicName + ".fifo";
            }

            // Add the attributes from the method parameters.
            createTopicRequest.Attributes = new Dictionary<string, string>
            {
                { "FifoTopic", "true" }
            };
            if (useContentBasedDeduplication)
            {
                createTopicRequest.Attributes.Add("ContentBasedDeduplication", "true");
            }
        }

        var createResponse = await _amazonSNSClient.CreateTopicAsync(createTopicRequest);
        return createResponse.TopicArn;
    }

  • APIEinzelheiten finden Sie unter Referenz CreateTopic.AWS SDK for .NET API

C++
SDKfür C++
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

//! Create an Amazon Simple Notification Service (Amazon SNS) topic.
/*!
  \param topicName: An Amazon SNS topic name.
  \param topicARNResult: String to return the Amazon Resource Name (ARN) for the topic.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
 */
bool AwsDoc::SNS::createTopic(const Aws::String &topicName,
                              Aws::String &topicARNResult,
                              const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::SNS::SNSClient snsClient(clientConfiguration);

    Aws::SNS::Model::CreateTopicRequest request;
    request.SetName(topicName);

    const Aws::SNS::Model::CreateTopicOutcome outcome = snsClient.CreateTopic(request);

    if (outcome.IsSuccess()) {
        topicARNResult = outcome.GetResult().GetTopicArn();
        std::cout << "Successfully created an Amazon SNS topic " << topicName
                  << " with topic ARN '" << topicARNResult
                  << "'." << std::endl;

    }
    else {
        std::cerr << "Error creating topic " << topicName << ":" <<
                  outcome.GetError().GetMessage() << std::endl;
        topicARNResult.clear();
    }

    return outcome.IsSuccess();
}

  • APIEinzelheiten finden Sie CreateTopicunter AWS SDK for C++ APIReferenz.

CLI
AWS CLI

So erstellen Sie ein SNS-Thema

Im folgenden create-topic Beispiel wird ein SNS Thema mit dem Namen erstelltmy-topic.

aws sns create-topic \
    --name my-topic

Ausgabe:

{
    "ResponseMetadata": {
        "RequestId": "1469e8d7-1642-564e-b85d-a19b4b341f83"
    },
    "TopicArn": "arn:aws:sns:us-west-2:123456789012:my-topic"
}

Weitere Informationen finden Sie unter Using the AWS Command Line Interface with Amazon SQS and Amazon SNS im AWS Command Line Interface User Guide.

  • APIEinzelheiten finden Sie CreateTopicunter AWS CLI Befehlsreferenz.

Go
SDKfür Go V2
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 


// SnsActions encapsulates the Amazon Simple Notification Service (Amazon SNS) actions
// used in the examples.
type SnsActions struct {
	SnsClient *sns.Client
}



// CreateTopic creates an Amazon SNS topic with the specified name. You can optionally
// specify that the topic is created as a FIFO topic and whether it uses content-based
// deduplication instead of ID-based deduplication.
func (actor SnsActions) CreateTopic(ctx context.Context, topicName string, isFifoTopic bool, contentBasedDeduplication bool) (string, error) {
	var topicArn string
	topicAttributes := map[string]string{}
	if isFifoTopic {
		topicAttributes["FifoTopic"] = "true"
	}
	if contentBasedDeduplication {
		topicAttributes["ContentBasedDeduplication"] = "true"
	}
	topic, err := actor.SnsClient.CreateTopic(ctx, &sns.CreateTopicInput{
		Name:       aws.String(topicName),
		Attributes: topicAttributes,
	})
	if err != nil {
		log.Printf("Couldn't create topic %v. Here's why: %v\n", topicName, err)
	} else {
		topicArn = *topic.TopicArn
	}

	return topicArn, err
}

  • APIEinzelheiten finden Sie CreateTopicunter AWS SDK for Go APIReferenz.

Java
SDKfür Java 2.x
Anmerkung

Es gibt noch mehr dazu. GitHub Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.CreateTopicRequest;
import software.amazon.awssdk.services.sns.model.CreateTopicResponse;
import software.amazon.awssdk.services.sns.model.SnsException;

/**
 * Before running this Java V2 code example, set up your development
 * environment, including your credentials.
 *
 * For more information, see the following documentation topic:
 *
 * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */
public class CreateTopic {
    public static void main(String[] args) {
        final String usage = """

                Usage:    <topicName>

                Where:
                   topicName - The name of the topic to create (for example, mytopic).

                """;

        if (args.length != 1) {
            System.out.println(usage);
            System.exit(1);
        }

        String topicName = args[0];
        System.out.println("Creating a topic with name: " + topicName);
        SnsClient snsClient = SnsClient.builder()
                .region(Region.US_EAST_1)
                .build();

        String arnVal = createSNSTopic(snsClient, topicName);
        System.out.println("The topic ARN is" + arnVal);
        snsClient.close();
    }

    public static String createSNSTopic(SnsClient snsClient, String topicName) {
        CreateTopicResponse result;
        try {
            CreateTopicRequest request = CreateTopicRequest.builder()
                    .name(topicName)
                    .build();

            result = snsClient.createTopic(request);
            return result.topicArn();

        } catch (SnsException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return "";
    }
}

  • APIEinzelheiten finden Sie CreateTopicunter AWS SDK for Java 2.x APIReferenz.

JavaScript
SDKfür JavaScript (v3)
Anmerkung

Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel- einrichten und ausführen.

Erstellen Sie den Client in einem separaten Modul und exportieren Sie ihn.

import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});

Importieren Sie die Module SDK und den Client und rufen Sie die aufAPI.

import { CreateTopicCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicName - The name of the topic to create.
 */
export const createTopic = async (topicName = "TOPIC_NAME") => {
  const response = await snsClient.send(
    new CreateTopicCommand({ Name: topicName }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '087b8ad2-4593-50c4-a496-d7e90b82cf3e',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   TopicArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:TOPIC_NAME'
  // }
  return response;
};
Kotlin
SDKfür Kotlin
Anmerkung

Es gibt noch mehr dazu. GitHub Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

suspend fun createSNSTopic(topicName: String): String {
    val request =
        CreateTopicRequest {
            name = topicName
        }

    SnsClient { region = "us-east-1" }.use { snsClient ->
        val result = snsClient.createTopic(request)
        return result.topicArn.toString()
    }
}

  • APIEinzelheiten finden Sie CreateTopicin der AWS SDKAPIKotlin-Referenz.

PHP
SDK für PHP
Anmerkung

Es gibt noch mehr dazu. GitHub Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel- einrichten und ausführen. 

require 'vendor/autoload.php';

use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;


/**
 * Create a Simple Notification Service topics in your AWS account at the requested region.
 *
 * This code expects that you have AWS credentials set up per:
 * https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
 */

$SnSclient = new SnsClient([
    'profile' => 'default',
    'region' => 'us-east-1',
    'version' => '2010-03-31'
]);

$topicname = 'myTopic';

try {
    $result = $SnSclient->createTopic([
        'Name' => $topicname,
    ]);
    var_dump($result);
} catch (AwsException $e) {
    // output error message if fails
    error_log($e->getMessage());
}
Python
SDKfür Python (Boto3)
Anmerkung

Es gibt noch mehr dazu. GitHub Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

class SnsWrapper:
    """Encapsulates Amazon SNS topic and subscription functions."""

    def __init__(self, sns_resource):
        """
        :param sns_resource: A Boto3 Amazon SNS resource.
        """
        self.sns_resource = sns_resource


    def create_topic(self, name):
        """
        Creates a notification topic.

        :param name: The name of the topic to create.
        :return: The newly created topic.
        """
        try:
            topic = self.sns_resource.create_topic(Name=name)
            logger.info("Created topic %s with ARN %s.", name, topic.arn)
        except ClientError:
            logger.exception("Couldn't create topic %s.", name)
            raise
        else:
            return topic

  • APIEinzelheiten finden Sie unter CreateTopicPython (Boto3) API -Referenz.AWS SDK

Ruby
SDKfür Ruby
Anmerkung

Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel- einrichten und ausführen. 

# This class demonstrates how to create an Amazon Simple Notification Service (SNS) topic.
class SNSTopicCreator
  # Initializes an SNS client.
  #
  # Utilizes the default AWS configuration for region and credentials.
  def initialize
    @sns_client = Aws::SNS::Client.new
  end

  # Attempts to create an SNS topic with the specified name.
  #
  # @param topic_name [String] The name of the SNS topic to create.
  # @return [Boolean] true if the topic was successfully created, false otherwise.
  def create_topic(topic_name)
    @sns_client.create_topic(name: topic_name)
    puts "The topic '#{topic_name}' was successfully created."
    true
  rescue Aws::SNS::Errors::ServiceError => e
    # Handles SNS service errors gracefully.
    puts "Error while creating the topic named '#{topic_name}': #{e.message}"
    false
  end
end

# Example usage:
if $PROGRAM_NAME == __FILE__
  topic_name = 'YourTopicName' # Replace with your topic name
  sns_topic_creator = SNSTopicCreator.new

  puts "Creating the topic '#{topic_name}'..."
  unless sns_topic_creator.create_topic(topic_name)
    puts 'The topic was not created. Stopping program.'
    exit 1
  end
end
Rust
SDKfür Rust
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

async fn make_topic(client: &Client, topic_name: &str) -> Result<(), Error> {
    let resp = client.create_topic().name(topic_name).send().await?;

    println!(
        "Created topic with ARN: {}",
        resp.topic_arn().unwrap_or_default()
    );

    Ok(())
}

  • APIEinzelheiten finden Sie CreateTopicin der AWS SDKAPIRust-Referenz.

SAP ABAP
SDKfür SAP ABAP
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

    TRY.
        oo_result = lo_sns->createtopic( iv_name = iv_topic_name ). " oo_result is returned for testing purposes. "
        MESSAGE 'SNS topic created' TYPE 'I'.
      CATCH /aws1/cx_snstopiclimitexcdex.
        MESSAGE 'Unable to create more topics. You have reached the maximum number of topics allowed.' TYPE 'E'.
    ENDTRY.

  • APIEinzelheiten finden Sie CreateTopicunter AWS SDKSAPABAPAPIals Referenz.

Anmerkung

Sie können ein SNS Amazon-Thema auch in einem anderen Konto verwenden. In diesem Fall müssen Sie jedoch möglicherweise eine Richtlinie für das Thema erstellen, die Zugriffsberechtigungen für gewährt AWS Config. Informationen zum Erteilen von Berechtigungen für ein SNS Amazon-Thema finden Sie unter Berechtigungen für das SNS Amazon-Thema und dann unterSchritt 3: Eine IAM Rolle erstellen.

Schritt 3: Eine IAM Rolle erstellen

Sie können die IAM Konsole verwenden, um eine IAM Rolle zu erstellen, die AWS Config Berechtigungen für den Zugriff auf Ihren Amazon S3 S3-Bucket, auf Ihr SNS Amazon-Thema und das Abrufen von Konfigurationsdetails für unterstützte AWS Ressourcen gewährt. Wenn Sie die Konsole verwenden, um eine IAM Rolle zu erstellen, AWS Config werden der Rolle automatisch die erforderlichen Berechtigungen für Sie zugewiesen.

Anmerkung

Wenn Sie einen AWS Dienst verwendet haben, der verwendet AWS Config (z. B. AWS Security Hub oder AWS Control Tower) und bereits eine AWS Config Rolle erstellt wurde, sollten Sie sicherstellen, dass die IAM Rolle, die Sie bei der Einrichtung verwenden, dieselben Mindestberechtigungen wie die bereits erstellte AWS Config Rolle AWS Config beibehält, damit der andere AWS Dienst weiterhin wie erwartet ausgeführt werden kann.

Wenn AWS Control Tower beispielsweise über eine IAM Rolle verfügt, die das Lesen von Amazon S3 S3-Objekten ermöglicht AWS Config , sollten Sie sicherstellen, dass innerhalb der IAM Rolle, die Sie bei der Einrichtung verwenden, dieselben Berechtigungen gewährt werden AWS Config. Andernfalls kann es den Betrieb von AWS Control Tower beeinträchtigen.

Weitere Informationen zu IAM Rollen für finden Sie AWS Config unter AWS Identity and Access Management.

Um eine Rolle für einen AWS Dienst zu erstellen

  1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die IAM Konsole unter https://console.aws.amazon.com/iam/.

  2. Wählen Sie im Navigationsbereich der IAM Konsole Rollen und anschließend Rolle erstellen aus.

  3. Wählen Sie für Select trusted entity (Vertrauenswürdige Entität auswählen) die Option AWS -Dienst.

  4. Wählen Sie den gewünschten Anwendungsfall für AWS Config: Config — Customizable, Config — Organizations, Config oder Config — Conformance Packs. Wählen Sie anschließend Weiter.

  5. Überprüfen Sie auf der Seite Name, prüfen und erstellen die Details zu Ihrer Rolle und wählen Sie Rolle erstellen aus.

Um eine zu verwenden AWS SDK, müssen Sie sie mit Ihren Anmeldeinformationen konfigurieren. Weitere Informationen finden Sie unter The shared config and credentials files im Referenzhandbuch AWS SDKsund im Tools-Referenzhandbuch.

Die folgenden Codebeispiele zeigen die VerwendungCreateRole.

.NET
AWS SDK for .NET
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

    /// <summary>
    /// Create a new IAM role.
    /// </summary>
    /// <param name="roleName">The name of the IAM role.</param>
    /// <param name="rolePolicyDocument">The name of the IAM policy document
    /// for the new role.</param>
    /// <returns>The Amazon Resource Name (ARN) of the role.</returns>
    public async Task<string> CreateRoleAsync(string roleName, string rolePolicyDocument)
    {
        var request = new CreateRoleRequest
        {
            RoleName = roleName,
            AssumeRolePolicyDocument = rolePolicyDocument,
        };

        var response = await _IAMService.CreateRoleAsync(request);
        return response.Role.Arn;
    }

  • APIEinzelheiten finden Sie CreateRoleunter AWS SDK for .NET APIReferenz.

Bash
AWS CLI mit Bash-Skript
Anmerkung

Es gibt noch mehr dazu. GitHub Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

###############################################################################
# function errecho
#
# This function outputs everything sent to it to STDERR (standard error output).
###############################################################################
function errecho() {
  printf "%s\n" "$*" 1>&2
}

###############################################################################
# function iam_create_role
#
# This function creates an IAM role.
#
# Parameters:
#       -n role_name -- The name of the IAM role.
#       -p policy_json -- The assume role policy document.
#
# Returns:
#       The ARN of the role.
#     And:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_create_role() {
  local role_name policy_document response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_create_user_access_key"
    echo "Creates an AWS Identity and Access Management (IAM) role."
    echo "  -n role_name   The name of the IAM role."
    echo "  -p policy_json -- The assume role policy document."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:p:h" option; do
    case "${option}" in
      n) role_name="${OPTARG}" ;;
      p) policy_document="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$role_name" ]]; then
    errecho "ERROR: You must provide a role name with the -n parameter."
    usage
    return 1
  fi

  if [[ -z "$policy_document" ]]; then
    errecho "ERROR: You must provide a policy document with the -p parameter."
    usage
    return 1
  fi

  response=$(aws iam create-role \
    --role-name "$role_name" \
    --assume-role-policy-document "$policy_document" \
    --output text \
    --query Role.Arn)

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports create-role operation failed.\n$response"
    return 1
  fi

  echo "$response"

  return 0
}

  • APIEinzelheiten finden Sie CreateRolein der AWS CLI Befehlsreferenz.

C++
SDKfür C++
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

bool AwsDoc::IAM::createIamRole(
        const Aws::String &roleName,
        const Aws::String &policy,
        const Aws::Client::ClientConfiguration &clientConfig) {
    Aws::IAM::IAMClient client(clientConfig);
    Aws::IAM::Model::CreateRoleRequest request;

    request.SetRoleName(roleName);
    request.SetAssumeRolePolicyDocument(policy);

    Aws::IAM::Model::CreateRoleOutcome outcome = client.CreateRole(request);
    if (!outcome.IsSuccess()) {
        std::cerr << "Error creating role. " <<
                  outcome.GetError().GetMessage() << std::endl;
    }
    else {
        const Aws::IAM::Model::Role iamRole = outcome.GetResult().GetRole();
        std::cout << "Created role " << iamRole.GetRoleName() << "\n";
        std::cout << "ID: " << iamRole.GetRoleId() << "\n";
        std::cout << "ARN: " << iamRole.GetArn() << std::endl;
    }

    return outcome.IsSuccess();
}

  • APIEinzelheiten finden Sie CreateRoleunter AWS SDK for C++ APIReferenz.

CLI
AWS CLI

Beispiel 1: Um eine IAM Rolle zu erstellen

Mit dem folgenden create-role-Befehl wird eine Rolle mit dem Namen Test-Role erstellt und ihr eine Vertrauensrichtlinie angefügt.

aws iam create-role \
    --role-name Test-Role \
    --assume-role-policy-document file://Test-Role-Trust-Policy.json

Ausgabe:

{
    "Role": {
        "AssumeRolePolicyDocument": "<URL-encoded-JSON>",
        "RoleId": "AKIAIOSFODNN7EXAMPLE",
        "CreateDate": "2013-06-07T20:43:32.821Z",
        "RoleName": "Test-Role",
        "Path": "/",
        "Arn": "arn:aws:iam::123456789012:role/Test-Role"
    }
}

Die Vertrauensrichtlinie ist als JSON Dokument in der Datei Test-Role-Trust-Policy.json definiert. (Der Dateiname und die Erweiterung sind nicht von Bedeutung.) Die Vertrauensrichtlinie muss einen Prinzipal angeben.

Verwenden Sie den put-role-policy-Befehl, um die Berechtigungsrichtlinie der Rolle anzufügen.

Weitere Informationen finden Sie im Benutzerhandbuch unter Rollen erstellen. IAM AWS IAM

Beispiel 2: Um eine IAM Rolle mit einer bestimmten maximalen Sitzungsdauer zu erstellen

Mit dem folgenden create-role-Befehl wird eine Rolle mit dem Namen Test-Role erstellt und eine maximale Sitzungsdauer von 7 200 Sekunden (2 Stunden) festgelegt.

aws iam create-role \
    --role-name Test-Role \
    --assume-role-policy-document file://Test-Role-Trust-Policy.json \
    --max-session-duration 7200

Ausgabe:

{
    "Role": {
        "Path": "/",
        "RoleName": "Test-Role",
        "RoleId": "AKIAIOSFODNN7EXAMPLE",
        "Arn": "arn:aws:iam::12345678012:role/Test-Role",
        "CreateDate": "2023-05-24T23:50:25+00:00",
        "AssumeRolePolicyDocument": {
            "Version": "2012-10-17",
            "Statement": [
                {
                    "Sid": "Statement1",
                    "Effect": "Allow",
                    "Principal": {
                        "AWS": "arn:aws:iam::12345678012:root"
                    },
                    "Action": "sts:AssumeRole"
                }
            ]
        }
    }
}

Weitere Informationen finden Sie im AWS IAMBenutzerhandbuch unter Ändern der maximalen Sitzungsdauer einer Rolle (AWS API).

Beispiel 3: So erstellen Sie eine IAM Rolle mit Tags

Der folgende Befehl erstellt eine IAM Rolle Test-Role mit Tags. In diesem Beispiel wird das --tags Parameter-Flag mit den folgenden JSON -formatierten Tags verwendet:. '{"Key": "Department", "Value": "Accounting"}' '{"Key": "Location", "Value": "Seattle"}' Alternativ kann das --tags-Flag mit Tags im Kurzformat 'Key=Department,Value=Accounting Key=Location,Value=Seattle' verwendet werden.

aws iam create-role \
    --role-name Test-Role \
    --assume-role-policy-document file://Test-Role-Trust-Policy.json \
    --tags '{"Key": "Department", "Value": "Accounting"}' '{"Key": "Location", "Value": "Seattle"}'

Ausgabe:

{
    "Role": {
        "Path": "/",
        "RoleName": "Test-Role",
        "RoleId": "AKIAIOSFODNN7EXAMPLE",
        "Arn": "arn:aws:iam::123456789012:role/Test-Role",
        "CreateDate": "2023-05-25T23:29:41+00:00",
        "AssumeRolePolicyDocument": {
            "Version": "2012-10-17",
            "Statement": [
                {
                    "Sid": "Statement1",
                    "Effect": "Allow",
                    "Principal": {
                        "AWS": "arn:aws:iam::123456789012:root"
                    },
                    "Action": "sts:AssumeRole"
                }
            ]
        },
        "Tags": [
            {
                "Key": "Department",
                "Value": "Accounting"
            },
            {
                "Key": "Location",
                "Value": "Seattle"
            }
        ]
    }
}

Weitere Informationen finden Sie unter IAMRollen taggen im AWS IAM Benutzerhandbuch.

  • APIEinzelheiten finden Sie CreateRolein der AWS CLI Befehlsreferenz.

Go
SDKfür Go V2
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 


// RoleWrapper encapsulates AWS Identity and Access Management (IAM) role actions
// used in the examples.
// It contains an IAM service client that is used to perform role actions.
type RoleWrapper struct {
	IamClient *iam.Client
}



// CreateRole creates a role that trusts a specified user. The trusted user can assume
// the role to acquire its permissions.
// PolicyDocument shows how to work with a policy document as a data structure and
// serialize it to JSON by using Go's JSON marshaler.
func (wrapper RoleWrapper) CreateRole(ctx context.Context, roleName string, trustedUserArn string) (*types.Role, error) {
	var role *types.Role
	trustPolicy := PolicyDocument{
		Version: "2012-10-17",
		Statement: []PolicyStatement{{
			Effect:    "Allow",
			Principal: map[string]string{"AWS": trustedUserArn},
			Action:    []string{"sts:AssumeRole"},
		}},
	}
	policyBytes, err := json.Marshal(trustPolicy)
	if err != nil {
		log.Printf("Couldn't create trust policy for %v. Here's why: %v\n", trustedUserArn, err)
		return nil, err
	}
	result, err := wrapper.IamClient.CreateRole(ctx, &iam.CreateRoleInput{
		AssumeRolePolicyDocument: aws.String(string(policyBytes)),
		RoleName:                 aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't create role %v. Here's why: %v\n", roleName, err)
	} else {
		role = result.Role
	}
	return role, err
}

  • APIEinzelheiten finden Sie CreateRoleunter AWS SDK for Go APIReferenz.

Java
SDKfür Java 2.x
Anmerkung

Es gibt noch mehr dazu. GitHub Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import software.amazon.awssdk.services.iam.model.CreateRoleRequest;
import software.amazon.awssdk.services.iam.model.CreateRoleResponse;
import software.amazon.awssdk.services.iam.model.IamException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.iam.IamClient;
import java.io.FileReader;

/*
*   This example requires a trust policy document. For more information, see:
*   https://aws.amazon.com/blogs/security/how-to-use-trust-policies-with-iam-roles/
*
*
*  In addition, set up your development environment, including your credentials.
*
*  For information, see this documentation topic:
*
*  https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */

public class CreateRole {
    public static void main(String[] args) throws Exception {
        final String usage = """
                Usage:
                    <rolename> <fileLocation>\s

                Where:
                    rolename - The name of the role to create.\s
                    fileLocation - The location of the JSON document that represents the trust policy.\s
                """;

        if (args.length != 2) {
            System.out.println(usage);
            System.exit(1);
        }

        String rolename = args[0];
        String fileLocation = args[1];
        Region region = Region.AWS_GLOBAL;
        IamClient iam = IamClient.builder()
                .region(region)
                .build();

        String result = createIAMRole(iam, rolename, fileLocation);
        System.out.println("Successfully created user: " + result);
        iam.close();
    }

    public static String createIAMRole(IamClient iam, String rolename, String fileLocation) throws Exception {
        try {
            JSONObject jsonObject = (JSONObject) readJsonSimpleDemo(fileLocation);
            CreateRoleRequest request = CreateRoleRequest.builder()
                    .roleName(rolename)
                    .assumeRolePolicyDocument(jsonObject.toJSONString())
                    .description("Created using the AWS SDK for Java")
                    .build();

            CreateRoleResponse response = iam.createRole(request);
            System.out.println("The ARN of the role is " + response.role().arn());

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return "";
    }

    public static Object readJsonSimpleDemo(String filename) throws Exception {
        FileReader reader = new FileReader(filename);
        JSONParser jsonParser = new JSONParser();
        return jsonParser.parse(reader);
    }
}

  • APIEinzelheiten finden Sie CreateRoleunter AWS SDK for Java 2.x APIReferenz.

JavaScript
SDKfür JavaScript (v3)
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen.

Erstellen Sie die -Rolle.

import { CreateRoleCommand, IAMClient } from "@aws-sdk/client-iam";

const client = new IAMClient({});

/**
 *
 * @param {string} roleName
 */
export const createRole = (roleName) => {
  const command = new CreateRoleCommand({
    AssumeRolePolicyDocument: JSON.stringify({
      Version: "2012-10-17",
      Statement: [
        {
          Effect: "Allow",
          Principal: {
            Service: "lambda.amazonaws.com",
          },
          Action: "sts:AssumeRole",
        },
      ],
    }),
    RoleName: roleName,
  });

  return client.send(command);
};

  • APIEinzelheiten finden Sie CreateRoleunter AWS SDK for JavaScript APIReferenz.

PHP
SDK für PHP
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

$uuid = uniqid();
$service = new IAMService();

$assumeRolePolicyDocument = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Principal\": {\"AWS\": \"{$user['Arn']}\"},
                    \"Action\": \"sts:AssumeRole\"
                }]
            }";
$assumeRoleRole = $service->createRole("iam_demo_role_$uuid", $assumeRolePolicyDocument);
echo "Created role: {$assumeRoleRole['RoleName']}\n";

    /**
     * @param string $roleName
     * @param string $rolePolicyDocument
     * @return array
     * @throws AwsException
     */
    public function createRole(string $roleName, string $rolePolicyDocument)
    {
        $result = $this->customWaiter(function () use ($roleName, $rolePolicyDocument) {
            return $this->iamClient->createRole([
                'AssumeRolePolicyDocument' => $rolePolicyDocument,
                'RoleName' => $roleName,
            ]);
        });
        return $result['Role'];
    }

  • APIEinzelheiten finden Sie CreateRoleunter AWS SDK for PHP APIReferenz.

PowerShell
Tools für PowerShell

Beispiel 1: In diesem Beispiel wird eine neue Rolle mit dem Namen erstellt MyNewRole und ihr die in der Datei NewRoleTrustPolicy.json enthaltene Richtlinie angehängt. Beachten Sie, dass Sie den -Raw Switch-Parameter verwenden müssen, um die JSON Richtliniendatei erfolgreich zu verarbeiten. Das in der Ausgabe angezeigte Richtliniendokument ist URL codiert. Es wird in diesem Beispiel mit dem dekodiert. UrlDecode NETMethode.

$results = New-IAMRole -AssumeRolePolicyDocument (Get-Content -raw NewRoleTrustPolicy.json) -RoleName MyNewRole
$results

Ausgabe:

Arn                      : arn:aws:iam::123456789012:role/MyNewRole
AssumeRolePolicyDocument : %7B%0D%0A%20%20%22Version%22%3A%20%222012-10-17%22%2C%0D%0A%20%20%22Statement%22
                           %3A%20%5B%0D%0A%20%20%20%20%7B%0D%0A%20%20%20%20%20%20%22Sid%22%3A%20%22%22%2C
                           %0D%0A%20%20%20%20%20%20%22Effect%22%3A%20%22Allow%22%2C%0D%0A%20%20%20%20%20%20
                           %22Principal%22%3A%20%7B%0D%0A%20%20%20%20%20%20%20%20%22AWS%22%3A%20%22arn%3Aaws
                           %3Aiam%3A%3A123456789012%3ADavid%22%0D%0A%20%20%20%20%20%20%7D%2C%0D%0A%20%20%20
                           %20%20%20%22Action%22%3A%20%22sts%3AAssumeRole%22%0D%0A%20%20%20%20%7D%0D%0A%20
                           %20%5D%0D%0A%7D
CreateDate               : 4/15/2015 11:04:23 AM
Path                     : /
RoleId                   : V5PAJI2KPN4EAEXAMPLE1
RoleName                 : MyNewRole

[System.Reflection.Assembly]::LoadWithPartialName("System.Web.HttpUtility")
[System.Web.HttpUtility]::UrlDecode($results.AssumeRolePolicyDocument)
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "",
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::123456789012:David"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
Python
SDKfür Python (Boto3)
Anmerkung

Es gibt noch mehr dazu. GitHub Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

def create_role(role_name, allowed_services):
    """
    Creates a role that lets a list of specified services assume the role.

    :param role_name: The name of the role.
    :param allowed_services: The services that can assume the role.
    :return: The newly created role.
    """
    trust_policy = {
        "Version": "2012-10-17",
        "Statement": [
            {
                "Effect": "Allow",
                "Principal": {"Service": service},
                "Action": "sts:AssumeRole",
            }
            for service in allowed_services
        ],
    }

    try:
        role = iam.create_role(
            RoleName=role_name, AssumeRolePolicyDocument=json.dumps(trust_policy)
        )
        logger.info("Created role %s.", role.name)
    except ClientError:
        logger.exception("Couldn't create role %s.", role_name)
        raise
    else:
        return role

  • APIEinzelheiten finden Sie unter CreateRolePython (Boto3) API -Referenz.AWS SDK

Ruby
SDKfür Ruby
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

  # Creates a role and attaches policies to it.
  #
  # @param role_name [String] The name of the role.
  # @param assume_role_policy_document [Hash] The trust relationship policy document.
  # @param policy_arns [Array<String>] The ARNs of the policies to attach.
  # @return [String, nil] The ARN of the new role if successful, or nil if an error occurred.
  def create_role(role_name, assume_role_policy_document, policy_arns)
    response = @iam_client.create_role(
      role_name: role_name,
      assume_role_policy_document: assume_role_policy_document.to_json
    )
    role_arn = response.role.arn

    policy_arns.each do |policy_arn|
      @iam_client.attach_role_policy(
        role_name: role_name,
        policy_arn: policy_arn
      )
    end

    role_arn
  rescue Aws::IAM::Errors::ServiceError => e
    @logger.error("Error creating role: #{e.message}")
    nil
  end

  • APIEinzelheiten finden Sie CreateRoleunter AWS SDK for Ruby APIReferenz.

Rust
SDKfür Rust
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

pub async fn create_role(
    client: &iamClient,
    role_name: &str,
    role_policy_document: &str,
) -> Result<Role, iamError> {
    let response: CreateRoleOutput = loop {
        if let Ok(response) = client
            .create_role()
            .role_name(role_name)
            .assume_role_policy_document(role_policy_document)
            .send()
            .await
        {
            break response;
        }
    };

    Ok(response.role.unwrap())
}

  • APIEinzelheiten finden Sie CreateRolein der AWS SDKAPIRust-Referenz.

Swift
SDKfür Swift
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

import AWSIAM
import AWSS3


    public func createRole(name: String, policyDocument: String) async throws -> String {
        let input = CreateRoleInput(
            assumeRolePolicyDocument: policyDocument,
            roleName: name
        )
        do {
            let output = try await client.createRole(input: input)
            guard let role = output.role else {
                throw ServiceHandlerError.noSuchRole
            }
            guard let id = role.roleId else {
                throw ServiceHandlerError.noSuchRole
            }
            return id
        } catch {
            print("ERROR: createRole:", dump(error))
            throw error
        }
    }

  • APIEinzelheiten finden Sie CreateRolein der AWS SDKAPISwift-Referenz.