AWS Resource Types by Category

import { ec2 } from "@pulumi/aws";

// Compute resources
new ec2.Instance("instance", { ami, instanceType, ... });
new ec2.LaunchTemplate("template", { imageId, instanceType, ... });
new ec2.SpotInstanceRequest("spot", { ami, instanceType, ... });
new ec2.Fleet("fleet", { launchTemplateConfigs, ... });

// Placement and capacity
new ec2.PlacementGroup("placement", { strategy: "cluster" });
new ec2.CapacityReservation("capacity", { instanceType, instancePlatform, ... });

// AMI management
new ec2.Ami("ami", { name, rootDeviceName, ... });
new ec2.AmiCopy("ami-copy", { sourceAmiId, sourceAmiRegion, ... });
new ec2.AmiLaunchPermission("launch-perm", { imageId, accountId });

import { lambda } from "@pulumi/aws";

// Functions
new lambda.Function("fn", { code, handler, runtime, role, ... });
new lambda.Alias("alias", { functionName, functionVersion, ... });
new lambda.FunctionUrl("url", { functionName, authorizationType, ... });

// Layers and configurations
new lambda.LayerVersion("layer", { layerName, code, ... });
new lambda.Permission("perm", { functionName, action, principal, ... });
new lambda.EventSourceMapping("mapping", { eventSourceArn, functionName, ... });
new lambda.ProvisionedConcurrencyConfig("concurrency", { functionName, provisionedConcurrentExecutions, ... });

// Code signing
new lambda.CodeSigningConfig("signing", { allowedPublishers, ... });

import { ecs } from "@pulumi/aws";

// Clusters
new ecs.Cluster("cluster", { name, ... });
new ecs.CapacityProvider("provider", { autoScalingGroupArn, ... });
new ecs.ClusterCapacityProviders("providers", { clusterName, capacityProviders, ... });

// Services and tasks
new ecs.Service("service", { cluster, taskDefinition, desiredCount, ... });
new ecs.TaskDefinition("task", { family, containerDefinitions, cpu, memory, ... });
new ecs.TaskSet("taskset", { cluster, service, taskDefinition, ... });

import { eks } from "@pulumi/aws";

// Clusters
new eks.Cluster("cluster", { roleArn, vpcConfig, ... });
new eks.NodeGroup("nodegroup", { clusterName, nodeRoleArn, subnetIds, ... });
new eks.FargateProfile("fargate", { clusterName, podExecutionRoleArn, selectors, ... });

// Add-ons and access
new eks.Addon("addon", { clusterName, addonName, ... });
new eks.AccessEntry("access", { clusterName, principalArn, ... });
new eks.AccessPolicyAssociation("policy", { clusterName, policyArn, principalArn, ... });
new eks.IdentityProviderConfig("oidc", { clusterName, oidc, ... });
new eks.PodIdentityAssociation("pod-identity", { clusterName, namespace, serviceAccount, roleArn, ... });

import { autoscaling } from "@pulumi/aws";

// Auto scaling groups
new autoscaling.Group("asg", { maxSize, minSize, launchTemplate, ... });
new autoscaling.Policy("policy", { autoscalingGroupName, policyType, ... });
new autoscaling.Schedule("schedule", { autoscalingGroupName, desiredCapacity, recurrence, ... });

// Lifecycle and notifications
new autoscaling.LifecycleHook("hook", { autoscalingGroupName, lifecycleTransition, ... });
new autoscaling.Notification("notification", { groupNames, notificationTypes, topicArn, ... });
new autoscaling.Attachment("attachment", { autoscalingGroupName, ... });

import { batch } from "@pulumi/aws";

new batch.ComputeEnvironment("compute", { type, serviceRole, ... });
new batch.JobDefinition("job", { type, containerProperties, ... });
new batch.JobQueue("queue", { computeEnvironments, priority, ... });
new batch.SchedulingPolicy("scheduling", { name, fairsharePolicy, ... });

import { elasticbeanstalk } from "@pulumi/aws";

new elasticbeanstalk.Application("app", { name, description, ... });
new elasticbeanstalk.ApplicationVersion("version", { application, bucket, key, ... });
new elasticbeanstalk.Environment("env", { application, solutionStackName, ... });
new elasticbeanstalk.ConfigurationTemplate("template", { application, ... });

import { lightsail } from "@pulumi/aws";

new lightsail.Instance("instance", { availabilityZone, blueprintId, bundleId, ... });
new lightsail.StaticIp("ip", { name });
new lightsail.StaticIpAttachment("attachment", { instanceName, staticIpName });
new lightsail.KeyPair("keypair", { name, publicKey });

import { s3 } from "@pulumi/aws";

// Buckets
new s3.Bucket("bucket", { bucketName, acl, ... });
new s3.BucketV2("bucket-v2", { bucket, ... });
new s3.BucketObject("object", { bucket, key, source, ... });
new s3.BucketObjectv2("object-v2", { bucket, key, source, ... });

// Bucket configuration
new s3.BucketPolicy("policy", { bucket, policy, ... });
new s3.BucketVersioning("versioning", { bucket, versioningConfiguration, ... });
new s3.BucketLifecycleConfiguration("lifecycle", { bucket, rules, ... });
new s3.BucketServerSideEncryptionConfiguration("encryption", { bucket, rules, ... });
new s3.BucketCorsConfiguration("cors", { bucket, corsRules, ... });
new s3.BucketPublicAccessBlock("pab", { bucket, blockPublicAcls, ... });

// Access points
new s3.AccessPoint("ap", { bucket, name, ... });
new s3.AccountPublicAccessBlock("account-pab", { blockPublicAcls, ... });

// Advanced features
new s3.Inventory("inventory", { bucket, destination, schedule, ... });
new s3.BucketMetric("metric", { bucket, name, ... });
new s3.AnalyticsConfiguration("analytics", { bucket, name, ... });

import { ebs } from "@pulumi/aws";

new ebs.Volume("volume", { availabilityZone, size, type, ... });
new ebs.Snapshot("snapshot", { volumeId, ... });
new ebs.SnapshotCopy("snapshot-copy", { sourceSnapshotId, sourceRegion, ... });
new ebs.EncryptionByDefault("encryption", { enabled: true });
new ebs.DefaultKmsKey("kms", { keyArn });

import { efs } from "@pulumi/aws";

new efs.FileSystem("fs", { encrypted, performanceMode, ... });
new efs.MountTarget("mount", { fileSystemId, subnetId, ... });
new efs.AccessPoint("ap", { fileSystemId, ... });
new efs.BackupPolicy("backup", { fileSystemId, backupPolicy, ... });
new efs.FileSystemPolicy("policy", { fileSystemId, policy, ... });
new efs.ReplicationConfiguration("replication", { sourceFileSystemId, destination, ... });

import { fsx } from "@pulumi/aws";

// File systems
new fsx.LustreFileSystem("lustre", { storageCapacity, subnetIds, ... });
new fsx.WindowsFileSystem("windows", { storageCapacity, subnetIds, throughputCapacity, ... });
new fsx.OntapFileSystem("ontap", { storageCapacity, subnetIds, ... });
new fsx.OpenZfsFileSystem("openzfs", { storageCapacity, subnetIds, ... });

// ONTAP resources
new fsx.OntapStorageVirtualMachine("svm", { fileSystemId, name, ... });
new fsx.OntapVolume("volume", { storageVirtualMachineId, name, ... });

// OpenZFS resources
new fsx.OpenZfsVolume("volume", { parentVolumeId, name, ... });
new fsx.OpenZfsSnapshot("snapshot", { volumeId, name, ... });

// Backup and cache
new fsx.Backup("backup", { fileSystemId, ... });
new fsx.FileCache("cache", { fileCacheType, subnetIds, ... });

import { glacier } from "@pulumi/aws";

new glacier.Vault("vault", { name, ... });
new glacier.VaultLock("lock", { vaultName, policy, completeLock, ... });

import { backup } from "@pulumi/aws";

new backup.Vault("vault", { name, ... });
new backup.Plan("plan", { name, rules, ... });
new backup.Selection("selection", { planId, iamRoleArn, resources, ... });
new backup.Framework("framework", { name, controls, ... });
new backup.VaultPolicy("policy", { backupVaultName, policy, ... });

import { storagegateway } from "@pulumi/aws";

new storagegateway.Gateway("gateway", { gatewayType, gatewayTimezone, ... });
new storagegateway.NfsFileShare("nfs", { clientList, gatewayArn, locationArn, roleArn, ... });
new storagegateway.SmbFileShare("smb", { gatewayArn, locationArn, roleArn, ... });
new storagegateway.Cache("cache", { diskId, gatewayArn });

import { rds } from "@pulumi/aws";

// Instances
new rds.Instance("db", { engine, instanceClass, allocatedStorage, ... });
new rds.Cluster("cluster", { engine, masterUsername, masterPassword, ... });
new rds.ClusterInstance("cluster-instance", { clusterIdentifier, instanceClass, ... });

// Global databases
new rds.GlobalCluster("global", { globalClusterIdentifier, engine, ... });

// Configuration
new rds.SubnetGroup("subnet-group", { subnetIds, ... });
new rds.ParameterGroup("params", { family, parameters, ... });
new rds.ClusterParameterGroup("cluster-params", { family, parameters, ... });
new rds.OptionGroup("options", { engineName, majorEngineVersion, ... });

// Proxy
new rds.Proxy("proxy", { engineFamily, auth, roleArn, vpcSubnetIds, ... });
new rds.ProxyDefaultTargetGroup("target", { dbProxyName, ... });
new rds.ProxyEndpoint("endpoint", { dbProxyName, vpcSubnetIds, ... });

// Snapshots and backups
new rds.Snapshot("snapshot", { dbInstanceIdentifier, ... });
new rds.ClusterSnapshot("cluster-snapshot", { dbClusterIdentifier, ... });

import { dynamodb } from "@pulumi/aws";

new dynamodb.Table("table", { attributes, hashKey, billingMode, ... });
new dynamodb.GlobalTable("global", { name, replicas, ... });
new dynamodb.GlobalSecondaryIndex("gsi", { tableName, name, hashKey, ... });
new dynamodb.TableItem("item", { tableName, hashKey, item, ... });
new dynamodb.KinesisStreamingDestination("stream", { tableName, streamArn, ... });

import { elasticache } from "@pulumi/aws";

// Clusters
new elasticache.Cluster("cache", { engine, nodeType, numCacheNodes, ... });
new elasticache.ReplicationGroup("redis", { replicationGroupId, engine, nodeType, ... });
new elasticache.ServerlessCache("serverless", { engine, serverlessCacheName, ... });

// Configuration
new elasticache.SubnetGroup("subnet-group", { subnetIds, ... });
new elasticache.ParameterGroup("params", { family, parameters, ... });

// Global and users
new elasticache.GlobalReplicationGroup("global", { globalReplicationGroupIdSuffix, primaryReplicationGroupId, ... });
new elasticache.User("user", { userId, userName, accessString, engine, ... });
new elasticache.UserGroup("group", { engine, userGroupId, userIds, ... });

import { docdb } from "@pulumi/aws";

new docdb.Cluster("cluster", { masterUsername, masterPassword, ... });
new docdb.ClusterInstance("instance", { clusterIdentifier, instanceClass, ... });
new docdb.SubnetGroup("subnet-group", { subnetIds, ... });
new docdb.ClusterParameterGroup("params", { family, parameters, ... });
new docdb.GlobalCluster("global", { globalClusterIdentifier, ... });
new docdb.ElasticCluster("elastic", { adminUserName, authType, shardCapacity, ... });

import { neptune } from "@pulumi/aws";

new neptune.Cluster("cluster", { engine, ... });
new neptune.ClusterInstance("instance", { clusterIdentifier, instanceClass, ... });
new neptune.SubnetGroup("subnet-group", { subnetIds, ... });
new neptune.ClusterParameterGroup("params", { family, parameters, ... });
new neptune.GlobalCluster("global", { globalClusterIdentifier, engine, ... });
new neptune.ClusterEndpoint("endpoint", { clusterIdentifier, endpointType, ... });

import { redshift } from "@pulumi/aws";

new redshift.Cluster("cluster", { clusterIdentifier, nodeType, masterUsername, masterPassword, ... });
new redshift.SubnetGroup("subnet-group", { subnetIds, ... });
new redshift.ParameterGroup("params", { family, parameters, ... });
new redshift.SnapshotSchedule("schedule", { scheduleIdentifier, definitions, ... });
new redshift.EndpointAccess("endpoint", { endpointName, subnetGroupName, ... });

import { dax } from "@pulumi/aws";

new dax.Cluster("dax", { clusterName, iamRoleArn, nodeType, replicationFactor, ... });
new dax.SubnetGroup("subnet-group", { subnetIds, ... });
new dax.ParameterGroup("params", { parameters, ... });

import { memorydb } from "@pulumi/aws";

new memorydb.Cluster("cluster", { aclName, nodeType, ... });
new memorydb.SubnetGroup("subnet-group", { subnetIds, ... });
new memorydb.ParameterGroup("params", { family, parameters, ... });
new memorydb.User("user", { userName, accessString, authenticationMode, ... });
new memorydb.Acl("acl", { userNames, ... });

import { keyspaces } from "@pulumi/aws";

new keyspaces.Keyspace("keyspace", { name, ... });
new keyspaces.Table("table", { keyspaceName, tableName, schemaDefinition, ... });

import { qldb } from "@pulumi/aws";

new qldb.Ledger("ledger", { name, permissionsMode, ... });
new qldb.Stream("stream", { ledgerName, roleArn, streamName, kinesisConfiguration, ... });

import { timestreamwrite } from "@pulumi/aws";

new timestreamwrite.Database("db", { databaseName, ... });
new timestreamwrite.Table("table", { databaseName, tableName, retentionProperties, ... });

import { ec2 } from "@pulumi/aws";

// Core VPC
new ec2.Vpc("vpc", { cidrBlock, enableDnsHostnames, enableDnsSupport, ... });
new ec2.Subnet("subnet", { vpcId, cidrBlock, availabilityZone, ... });
new ec2.InternetGateway("igw", { vpcId, ... });
new ec2.NatGateway("nat", { subnetId, allocationId, ... });
new ec2.Eip("eip", { domain: "vpc" });

// Routing
new ec2.RouteTable("rt", { vpcId, ... });
new ec2.Route("route", { routeTableId, destinationCidrBlock, gatewayId, ... });
new ec2.RouteTableAssociation("rta", { routeTableId, subnetId, ... });

// Security
new ec2.SecurityGroup("sg", { vpcId, ingress, egress, ... });
new ec2.SecurityGroupRule("rule", { securityGroupId, type, fromPort, toPort, protocol, ... });
new ec2.NetworkAcl("nacl", { vpcId, ... });
new ec2.NetworkAclRule("nacl-rule", { networkAclId, ruleNumber, protocol, ... });

// VPC Peering
new ec2.VpcPeeringConnection("peering", { vpcId, peerVpcId, ... });
new ec2.VpcPeeringConnectionAccepter("accepter", { vpcPeeringConnectionId, ... });

// VPC Endpoints
new ec2.VpcEndpoint("endpoint", { vpcId, serviceName, ... });
new ec2.VpcEndpointService("endpoint-svc", { acceptanceRequired, networkLoadBalancerArns, ... });

// IPAM
new ec2.VpcIpam("ipam", { operatingRegions, ... });
new ec2.VpcIpamPool("pool", { ipamScopeId, addressFamily, ... });

import { lb } from "@pulumi/aws";

// Load balancers
new lb.LoadBalancer("lb", { loadBalancerType, subnets, securityGroups, ... });
new lb.Listener("listener", { loadBalancerArn, port, protocol, defaultActions, ... });
new lb.ListenerRule("rule", { listenerArn, actions, conditions, ... });

// Target groups
new lb.TargetGroup("tg", { port, protocol, vpcId, targetType, ... });
new lb.TargetGroupAttachment("attachment", { targetGroupArn, targetId, ... });

// Certificates
new lb.ListenerCertificate("cert", { listenerArn, certificateArn });

// Trust stores
new lb.TrustStore("trust", { name, caCertificatesBundleS3Bucket, ... });

import { cloudfront } from "@pulumi/aws";

// Distributions
new cloudfront.Distribution("cdn", { origins, defaultCacheBehavior, enabled, ... });
new cloudfront.Function("fn", { code, runtime, ... });

// Cache and origin policies
new cloudfront.CachePolicy("cache", { name, minTtl, maxTtl, defaultTtl, parametersInCacheKeyAndForwardedToOrigin, ... });
new cloudfront.OriginRequestPolicy("origin", { name, cookiesConfig, headersConfig, queryStringsConfig, ... });
new cloudfront.ResponseHeadersPolicy("headers", { name, ... });

// Access control
new cloudfront.OriginAccessControl("oac", { name, originAccessControlOriginType, signingBehavior, signingProtocol, ... });
new cloudfront.OriginAccessIdentity("oai", { comment });

// Key management
new cloudfront.KeyGroup("keys", { items, name, ... });
new cloudfront.PublicKey("key", { encodedKey, name, ... });

import { route53 } from "@pulumi/aws";

// Hosted zones
new route53.Zone("zone", { name, ... });
new route53.Record("record", { zoneId, name, type, records, ... });

// Health checks
new route53.HealthCheck("health", { type, ... });

// Traffic policies
new route53.TrafficPolicy("policy", { name, document, ... });
new route53.TrafficPolicyInstance("instance", { hostedZoneId, name, trafficPolicyId, ... });

// DNSSEC
new route53.KeySigningKey("ksk", { hostedZoneId, keyManagementServiceArn, name, ... });
new route53.HostedZoneDnsSec("dnssec", { hostedZoneId });

// Query logging
new route53.QueryLog("query-log", { cloudwatchLogGroupArn, zoneId });

// Resolvers (for VPC DNS)
new route53.ResolverEndpoint("endpoint", { direction, ipAddresses, securityGroupIds, ... });
new route53.ResolverRule("rule", { domainName, ruleType, ... });
new route53.ResolverRuleAssociation("assoc", { resolverRuleId, vpcId });

import { apigateway, apigatewayv2 } from "@pulumi/aws";

// REST API (v1)
new apigateway.RestApi("api", { name, ... });
new apigateway.Resource("resource", { restApi, parentId, pathPart, ... });
new apigateway.Method("method", { restApi, resourceId, httpMethod, authorization, ... });
new apigateway.Integration("integration", { restApi, resourceId, httpMethod, type, ... });
new apigateway.Deployment("deployment", { restApi, ... });
new apigateway.Stage("stage", { restApi, deployment, stageName, ... });

// HTTP/WebSocket API (v2)
new apigatewayv2.Api("api", { name, protocolType, ... });
new apigatewayv2.Route("route", { apiId, routeKey, ... });
new apigatewayv2.Integration("integration", { apiId, integrationType, ... });
new apigatewayv2.Stage("stage", { apiId, name, ... });
new apigatewayv2.Authorizer("auth", { apiId, authorizerType, ... });

// Custom domains
new apigateway.DomainName("domain", { domainName, certificateArn, ... });
new apigateway.BasePathMapping("mapping", { domainName, restApi, ... });

import { vpclattice } from "@pulumi/aws";

new vpclattice.Service("service", { name, ... });
new vpclattice.ServiceNetwork("network", { name, ... });
new vpclattice.ServiceNetworkVpcAssociation("vpc-assoc", { serviceNetworkIdentifier, vpcIdentifier, ... });
new vpclattice.ServiceNetworkServiceAssociation("svc-assoc", { serviceIdentifier, serviceNetworkIdentifier, ... });
new vpclattice.TargetGroup("tg", { name, type, ... });
new vpclattice.Listener("listener", { serviceIdentifier, defaultAction, protocol, ... });

import { directconnect } from "@pulumi/aws";

new directconnect.Connection("connection", { bandwidth, location, name, ... });
new directconnect.Gateway("gateway", { amazonSideAsn, name, ... });
new directconnect.GatewayAssociation("assoc", { dxGatewayId, associatedGatewayId, ... });
new directconnect.PrivateVirtualInterface("vif", { connectionId, vlan, bgpAsn, ... });

import { ec2transitgateway } from "@pulumi/aws";

new ec2transitgateway.TransitGateway("tgw", { amazonSideAsn, ... });
new ec2transitgateway.VpcAttachment("vpc-attach", { subnetIds, transitGatewayId, vpcId, ... });
new ec2transitgateway.RouteTable("rt", { transitGatewayId, ... });
new ec2transitgateway.Route("route", { destinationCidrBlock, transitGatewayAttachmentId, transitGatewayRouteTableId, ... });
new ec2transitgateway.PeeringAttachment("peering", { peerTransitGatewayId, transitGatewayId, ... });

import { globalaccelerator } from "@pulumi/aws";

new globalaccelerator.Accelerator("accelerator", { name, enabled, ipAddressType, ... });
new globalaccelerator.Listener("listener", { acceleratorArn, portRanges, protocol, ... });
new globalaccelerator.EndpointGroup("endpoint-group", { listenerArn, endpointGroupRegion, endpointConfigurations, ... });

import { iam } from "@pulumi/aws";

// Users and groups
new iam.User("user", { name, ... });
new iam.Group("group", { name, ... });
new iam.GroupMembership("membership", { group, users, ... });
new iam.AccessKey("key", { user });

// Roles
new iam.Role("role", { assumeRolePolicy, ... });
new iam.RolePolicy("inline-policy", { role, policy, ... });
new iam.RolePolicyAttachment("attach", { role, policyArn });

// Policies
new iam.Policy("policy", { name, policy, ... });
new iam.PolicyAttachment("attach", { policyArn, users, roles, groups, ... });

// Instance profiles
new iam.InstanceProfile("profile", { role, ... });

// Identity providers
new iam.OpenIdConnectProvider("oidc", { url, clientIdLists, thumbprintLists, ... });
new iam.SamlProvider("saml", { name, samlMetadataDocument });

// Service-linked roles
new iam.ServiceLinkedRole("slr", { awsServiceName, ... });

import { kms } from "@pulumi/aws";

new kms.Key("key", { description, keyUsage, customerMasterKeySpec, ... });
new kms.Alias("alias", { name, targetKeyId });
new kms.Grant("grant", { keyId, granteePrincipal, operations, ... });
new kms.KeyPolicy("policy", { keyId, policy });
new kms.ExternalKey("external", { ... });
new kms.ReplicaKey("replica", { primaryKeyArn, ... });

import { secretsmanager } from "@pulumi/aws";

new secretsmanager.Secret("secret", { name, description, ... });
new secretsmanager.SecretVersion("version", { secretId, secretString, ... });
new secretsmanager.SecretRotation("rotation", { secretId, rotationLambdaArn, rotationRules, ... });
new secretsmanager.SecretPolicy("policy", { secretArn, policy });

import { acm } from "@pulumi/aws";

new acm.Certificate("cert", { domainName, validationMethod, subjectAlternativeNames, ... });
new acm.CertificateValidation("validation", { certificateArn, validationRecordFqdns, ... });

import { securityhub } from "@pulumi/aws";

new securityhub.Account("account", {});
new securityhub.StandardsSubscription("standards", { standardsArn });
new securityhub.FindingAggregator("aggregator", { linkingMode, ... });
new securityhub.ActionTarget("action", { identifier, name, description });
new securityhub.Insight("insight", { filters, groupByAttribute, name, ... });

import { guardduty } from "@pulumi/aws";

new guardduty.Detector("detector", { enable: true, ... });
new guardduty.Filter("filter", { detectorId, name, action, findingCriteria, ... });
new guardduty.IPSet("ipset", { detectorId, format, location, name, ... });
new guardduty.ThreatIntelSet("threats", { detectorId, format, location, name, ... });
new guardduty.Member("member", { accountId, detectorId, email, ... });

import { wafv2 } from "@pulumi/aws";

new wafv2.WebAcl("acl", { scope, defaultAction, rules, visibilityConfig, ... });
new wafv2.RuleGroup("rules", { capacity, scope, visibilityConfig, ... });
new wafv2.IpSet("ipset", { scope, ipAddressVersion, addresses, ... });
new wafv2.RegexPatternSet("regex", { scope, regularExpressions, ... });
new wafv2.WebAclAssociation("assoc", { resourceArn, webAclArn });

import { shield } from "@pulumi/aws";

new shield.Protection("protection", { name, resourceArn, ... });
new shield.ProtectionGroup("group", { aggregation, pattern, protectionGroupId, ... });
new shield.Subscription("subscription", {});

import { cognito } from "@pulumi/aws";

// User pools
new cognito.UserPool("pool", { name, ... });
new cognito.UserPoolClient("client", { userPoolId, ... });
new cognito.UserPoolDomain("domain", { domain, userPoolId, ... });
new cognito.User("user", { userPoolId, username, ... });
new cognito.UserGroup("group", { name, userPoolId, ... });

// Identity pools
new cognito.IdentityPool("identity", { identityPoolName, allowUnauthenticatedIdentities, ... });
new cognito.IdentityPoolRoleAttachment("roles", { identityPoolId, roles, ... });
new cognito.IdentityProvider("provider", { providerName, providerType, userPoolId, ... });

import { macie2 } from "@pulumi/aws";

new macie2.Account("account", {});
new macie2.ClassificationJob("job", { jobType, s3JobDefinition, ... });
new macie2.Member("member", { accountId, email, ... });

import { inspector2 } from "@pulumi/aws";

new inspector2.Enabler("enabler", { accountIds, resourceTypes, ... });
new inspector2.DelegatedAdminAccount("admin", { accountId });
new inspector2.MemberAssociation("member", { accountId });

import { cloudwatch } from "@pulumi/aws";

// Logs
new cloudwatch.LogGroup("logs", { name, retentionInDays, ... });
new cloudwatch.LogStream("stream", { logGroupName, name });
new cloudwatch.LogSubscriptionFilter("filter", { logGroupName, filterPattern, destinationArn, ... });
new cloudwatch.LogMetricFilter("metric", { logGroupName, pattern, metricTransformation, ... });

// Alarms
new cloudwatch.MetricAlarm("alarm", { comparisonOperator, evaluationPeriods, metricName, namespace, threshold, ... });
new cloudwatch.CompositeAlarm("composite", { alarmName, alarmRule, ... });

// Dashboards
new cloudwatch.Dashboard("dashboard", { dashboardName, dashboardBody });

// Events
new cloudwatch.EventRule("rule", { eventPattern, scheduleExpression, ... });
new cloudwatch.EventTarget("target", { rule, arn, ... });
new cloudwatch.EventBus("bus", { name, ... });
new cloudwatch.EventConnection("connection", { authorizationType, authParameters, ... });

import { cloudtrail } from "@pulumi/aws";

new cloudtrail.Trail("trail", { s3BucketName, ... });
new cloudtrail.EventDataStore("datastore", { name, ... });

import { cfg } from "@pulumi/aws";

new cfg.Recorder("recorder", { name, roleArn, ... });
new cfg.DeliveryChannel("channel", { name, s3BucketName, ... });
new cfg.Rule("rule", { name, source, ... });
new cfg.RemediationConfiguration("remediation", { configRuleName, targetType, targetIdentifier, ... });

import { ssm } from "@pulumi/aws";

// Parameters
new ssm.Parameter("param", { name, type, value, ... });

// Documents
new ssm.Document("doc", { documentType, content, ... });

// Maintenance windows
new ssm.MaintenanceWindow("window", { name, schedule, duration, cutoff, ... });
new ssm.MaintenanceWindowTarget("target", { windowId, resourceType, targets, ... });
new ssm.MaintenanceWindowTask("task", { windowId, taskType, taskArn, ... });

// Patch management
new ssm.PatchBaseline("baseline", { name, operatingSystem, approvalRules, ... });
new ssm.PatchGroup("group", { baselineId, patchGroup });

// Associations
new ssm.Association("assoc", { name, targets, ... });

import { cloudformation } from "@pulumi/aws";

new cloudformation.Stack("stack", { name, templateBody, parameters, ... });
new cloudformation.StackSet("stackset", { name, templateBody, ... });
new cloudformation.StackSetInstance("instance", { stackSetName, accountId, region, ... });

import { organizations } from "@pulumi/aws";

new organizations.Organization("org", { featureSet, ... });
new organizations.Account("account", { name, email, ... });
new organizations.OrganizationalUnit("ou", { name, parentId, ... });
new organizations.Policy("policy", { name, type, content, ... });
new organizations.PolicyAttachment("attach", { policyId, targetId });

import { servicecatalog } from "@pulumi/aws";

new servicecatalog.Portfolio("portfolio", { name, providerName, ... });
new servicecatalog.Product("product", { name, owner, type, provisioningArtifactParameters, ... });
new servicecatalog.ProductPortfolioAssociation("assoc", { portfolioId, productId });
new servicecatalog.ProvisionedProduct("provisioned", { name, productId, ... });

import { resourcegroups } from "@pulumi/aws";

new resourcegroups.Group("group", { name, resourceQuery, ... });
new resourcegroups.Resource("resource", { groupArn, resourceArn });

import { athena } from "@pulumi/aws";

new athena.Database("db", { name, bucket, ... });
new athena.Workgroup("workgroup", { name, configuration, ... });
new athena.NamedQuery("query", { database, name, query, ... });
new athena.DataCatalog("catalog", { name, type, ... });

import { emr } from "@pulumi/aws";

new emr.Cluster("cluster", { name, releaseLabel, applications, ec2Attributes, serviceRole, ... });
new emr.InstanceGroup("group", { clusterId, instanceType, ... });
new emr.SecurityConfiguration("security", { configuration, ... });
new emr.Studio("studio", { name, authMode, vpcId, workspaceSecurityGroupId, ... });

import { glue } from "@pulumi/aws";

// Data catalog
new glue.CatalogDatabase("db", { name, ... });
new glue.CatalogTable("table", { databaseName, name, ... });
new glue.Crawler("crawler", { databaseName, role, targets, ... });

// Jobs
new glue.Job("job", { name, roleArn, command, ... });
new glue.Trigger("trigger", { name, type, actions, ... });
new glue.Workflow("workflow", { name, ... });

// Connections
new glue.Connection("connection", { connectionProperties, connectionType, ... });

import { kinesis } from "@pulumi/aws";

new kinesis.Stream("stream", { name, shardCount, ... });
new kinesis.StreamConsumer("consumer", { name, streamArn });
new kinesis.FirehoseDeliveryStream("firehose", { name, destination, ... });
new kinesis.AnalyticsApplication("analytics", { name, inputs, outputs, ... });
new kinesis.VideoStream("video", { name, dataRetentionInHours, ... });

import { msk } from "@pulumi/aws";

new msk.Cluster("kafka", { clusterName, kafkaVersion, numberOfBrokerNodes, brokerNodeGroupInfo, ... });
new msk.ServerlessCluster("serverless", { clusterName, vpcConfigs, ... });
new msk.Configuration("config", { kafkaVersions, serverProperties, ... });

import { opensearch } from "@pulumi/aws";

new opensearch.Domain("domain", { domainName, engineVersion, clusterConfig, ... });
new opensearch.ServerlessCollection("collection", { name, type, ... });
new opensearch.DomainPolicy("policy", { domainName, accessPolicies });

import { quicksight } from "@pulumi/aws";

new quicksight.DataSource("datasource", { dataSourceId, name, type, ... });
new quicksight.DataSet("dataset", { dataSetId, name, importMode, physicalTableMap, ... });
new quicksight.Dashboard("dashboard", { dashboardId, name, sourceEntity, ... });
new quicksight.Analysis("analysis", { analysisId, name, sourceEntity, ... });

import { lakeformation } from "@pulumi/aws";

new lakeformation.DataLakeSettings("settings", { admins, ... });
new lakeformation.Resource("resource", { arn, ... });
new lakeformation.Permissions("perms", { principal, resource, permissions, ... });
new lakeformation.LfTag("tag", { key, values, ... });

import { sns } from "@pulumi/aws";

new sns.Topic("topic", { name, ... });
new sns.TopicSubscription("sub", { topic, protocol, endpoint, ... });
new sns.TopicPolicy("policy", { arn, policy });
new sns.PlatformApplication("app", { name, platform, platformCredential, ... });

import { sqs } from "@pulumi/aws";

new sqs.Queue("queue", { name, delaySeconds, visibilityTimeoutSeconds, ... });
new sqs.QueuePolicy("policy", { queueUrl, policy });
new sqs.RedrivePolicy("redrive", { queueUrl, redrivePolicy });
new sqs.RedriveAllowPolicy("allow", { queueUrl, redriveAllowPolicy });

import { cloudwatch } from "@pulumi/aws";

new cloudwatch.EventBus("bus", { name, ... });
new cloudwatch.EventRule("rule", { eventBusName, eventPattern, scheduleExpression, ... });
new cloudwatch.EventTarget("target", { rule, arn, ... });
new cloudwatch.EventArchive("archive", { eventSourceArn, ... });
new cloudwatch.EventConnection("connection", { authorizationType, authParameters, ... });

import { sfn } from "@pulumi/aws";

new sfn.StateMachine("statemachine", { definition, roleArn, ... });
new sfn.Activity("activity", { name, ... });
new sfn.Alias("alias", { name, routingConfiguration, ... });

import { appsync } from "@pulumi/aws";

new appsync.GraphQLApi("api", { name, authenticationType, ... });
new appsync.DataSource("datasource", { apiId, name, type, ... });
new appsync.Resolver("resolver", { apiId, type, field, dataSource, ... });
new appsync.Function("function", { apiId, dataSource, name, ... });
new appsync.ApiKey("key", { apiId, ... });

import { pipes } from "@pulumi/aws";

new pipes.Pipe("pipe", { source, target, ... });

import { mq } from "@pulumi/aws";

new mq.Broker("broker", { brokerName, engineType, engineVersion, hostInstanceType, users, ... });
new mq.Configuration("config", { engineType, engineVersion, data, ... });

import { ecr } from "@pulumi/aws";

new ecr.Repository("repo", { name, imageScanningConfiguration, ... });
new ecr.RepositoryPolicy("policy", { repository, policy });
new ecr.LifecyclePolicy("lifecycle", { repository, policy });
new ecr.RegistryPolicy("registry", { policy });
new ecr.PullThroughCacheRule("cache", { ecrRepositoryPrefix, upstreamRegistryUrl, ... });

import { apprunner } from "@pulumi/aws";

new apprunner.Service("service", { serviceName, sourceConfiguration, ... });
new apprunner.Connection("connection", { connectionName, providerType, ... });
new apprunner.VpcConnector("connector", { vpcConnectorName, subnets, securityGroups, ... });
new apprunner.AutoScalingConfigurationVersion("autoscaling", { autoScalingConfigurationName, maxConcurrency, maxSize, minSize, ... });

import { codecommit } from "@pulumi/aws";

new codecommit.Repository("repo", { repositoryName, description, ... });
new codecommit.Trigger("trigger", { repositoryName, triggers, ... });
new codecommit.ApprovalRuleTemplate("template", { name, content, ... });

import { codebuild } from "@pulumi/aws";

new codebuild.Project("project", { name, source, artifacts, environment, serviceRole, ... });
new codebuild.ReportGroup("reports", { name, type, exportConfig, ... });
new codebuild.Webhook("webhook", { projectName, filterGroups, ... });
new codebuild.Fleet("fleet", { name, baseCapacity, computeType, ... });

import { codedeploy } from "@pulumi/aws";

new codedeploy.Application("app", { name, computePlatform, ... });
new codedeploy.DeploymentGroup("group", { appName, deploymentGroupName, serviceRoleArn, ... });
new codedeploy.DeploymentConfig("config", { deploymentConfigName, minimumHealthyHosts, ... });

import { codepipeline } from "@pulumi/aws";

new codepipeline.Pipeline("pipeline", { name, roleArn, artifactStore, stages, ... });
new codepipeline.Webhook("webhook", { name, targetPipeline, targetAction, authentication, filters, ... });

import { codeartifact } from "@pulumi/aws";

new codeartifact.Domain("domain", { domain, ... });
new codeartifact.Repository("repo", { repository, domain, ... });
new codeartifact.RepositoryPermissionsPolicy("policy", { repository, domain, policyDocument, ... });

import { sagemaker } from "@pulumi/aws";

// Models and endpoints
new sagemaker.Model("model", { name, executionRoleArn, primaryContainer, ... });
new sagemaker.EndpointConfiguration("config", { name, productionVariants, ... });
new sagemaker.Endpoint("endpoint", { name, endpointConfigName, ... });

// Notebooks
new sagemaker.NotebookInstance("notebook", { name, roleArn, instanceType, ... });

// Domains
new sagemaker.Domain("domain", { domainName, authMode, vpcId, subnetIds, defaultUserSettings, ... });
new sagemaker.UserProfile("profile", { domainId, userProfileName, ... });
new sagemaker.Space("space", { domainId, spaceName, ... });
new sagemaker.App("app", { domainId, userProfileName, appType, appName, ... });

// Pipelines and features
new sagemaker.Pipeline("pipeline", { pipelineName, pipelineDefinition, roleArn, ... });
new sagemaker.FeatureGroup("features", { featureGroupName, recordIdentifierFeatureName, eventTimeFeatureName, ... });

import { bedrock } from "@pulumi/aws";

new bedrock.AgentAgent("agent", { agentName, foundationModel, ... });
new bedrock.AgentKnowledgeBase("kb", { knowledgeBaseName, roleArn, ... });
new bedrock.AgentDataSource("datasource", { knowledgeBaseId, name, ... });
new bedrock.Guardrail("guardrail", { name, blockedInputMessaging, blockedOutputsMessaging, ... });
new bedrock.CustomModel("custommodel", { baseModelIdentifier, jobName, outputDataConfig, ... });

import { rekognition } from "@pulumi/aws";

new rekognition.Collection("collection", { collectionId });
new rekognition.Project("project", { name, ... });
new rekognition.StreamProcessor("processor", { name, input, output, roleArn, settings, ... });

import { dms } from "@pulumi/aws";

new dms.ReplicationInstance("instance", { replicationInstanceClass, replicationInstanceId, ... });
new dms.Endpoint("endpoint", { endpointId, endpointType, engineName, ... });
new dms.ReplicationTask("task", { replicationTaskId, replicationInstanceArn, sourceEndpointArn, targetEndpointArn, migrationType, tableMappings, ... });
new dms.ReplicationSubnetGroup("subnet", { replicationSubnetGroupId, subnetIds, ... });

import { datasync } from "@pulumi/aws";

new datasync.Agent("agent", { activationKey, ... });
new datasync.Task("task", { sourceLocationArn, destinationLocationArn, ... });
new datasync.S3Location("s3", { s3BucketArn, s3Config, ... });
new datasync.EfsLocation("efs", { efsFileSystemArn, ec2Config, ... });
new datasync.NfsLocation("nfs", { serverHostname, subdirectory, onPremConfig, ... });

import { transfer } from "@pulumi/aws";

new transfer.Server("server", { protocols, identityProviderType, ... });
new transfer.User("user", { serverId, userName, role, homeDirectory, ... });
new transfer.SshKey("key", { serverId, userName, body });
new transfer.Workflow("workflow", { steps, ... });

import { mediaconvert } from "@pulumi/aws";

new mediaconvert.Queue("queue", { name, ... });

import { medialive } from "@pulumi/aws";

new medialive.Channel("channel", { name, channelClass, destinations, encoderSettings, inputAttachments, ... });
new medialive.Input("input", { name, type, ... });
new medialive.InputSecurityGroup("sg", { whitelistRules, ... });
new medialive.Multiplex("multiplex", { name, availabilityZones, multiplexSettings, ... });

import { mediapackage } from "@pulumi/aws";

new mediapackage.Channel("channel", { channelId, description, ... });
new mediapackage.OriginEndpoint("endpoint", { channelId, id, ... });

import { elastictranscoder } from "@pulumi/aws";

new elastictranscoder.Pipeline("pipeline", { inputBucket, name, role, ... });
new elastictranscoder.Preset("preset", { container, name, ... });

import { workspaces } from "@pulumi/aws";

new workspaces.Directory("directory", { directoryId, subnetIds, ... });
new workspaces.Workspace("workspace", { bundleId, directoryId, userName, ... });
new workspaces.IpGroup("ipgroup", { name, rules, ... });

import { appstream } from "@pulumi/aws";

new appstream.Fleet("fleet", { name, computeCapacity, instanceType, ... });
new appstream.Stack("stack", { name, ... });
new appstream.FleetStackAssociation("assoc", { fleetName, stackName });
new appstream.ImageBuilder("builder", { instanceType, name, ... });
new appstream.User("user", { authenticationType, userName, ... });

import { connect } from "@pulumi/aws";

new connect.Instance("instance", { identityManagementType, inboundCallsEnabled, outboundCallsEnabled, ... });
new connect.ContactFlow("flow", { instanceId, name, type, content, ... });
new connect.Queue("queue", { instanceId, name, hoursOfOperationId, ... });
new connect.User("user", { instanceId, name, phoneConfig, routingProfileId, securityProfileIds, ... });
new connect.PhoneNumber("phone", { countryCode, targetArn, type, ... });

import { iot } from "@pulumi/aws";

new iot.Thing("thing", { name, ... });
new iot.ThingType("type", { name, ... });
new iot.ThingGroup("group", { name, ... });
new iot.Certificate("cert", { csr, ... });
new iot.Policy("policy", { name, policy, ... });
new iot.PolicyAttachment("attach", { policy, target });
new iot.TopicRule("rule", { name, enabled, sql, sqlVersion, actions, ... });