tessl/npm-pulumi--aws

A Pulumi package for creating and managing Amazon Web Services (AWS) cloud resources with infrastructure-as-code.

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview

Eval results

Files

AWS Data Sources by Category

Name: tessl/npm-pulumi--aws
Author: tessl

Comprehensive listing of all AWS data sources in @pulumi/aws, organized by service category. Data sources query existing infrastructure without managing it.

Quick Navigation

Overview

Data sources allow you to query existing AWS infrastructure that is managed outside of Pulumi. They are read-only and do not create, update, or delete resources.

Usage Pattern

import * as aws from "@pulumi/aws";

// Data sources use get* functions
const vpc = await aws.ec2.getVpc({ default: true });
const ami = await aws.ec2.getAmi({
    filters: [{ name: "name", values: ["amzn2-ami-hvm-*"] }],
    owners: ["amazon"],
    mostRecent: true
});

// Use Output-returning variants for resource inputs
const vpcOutput = aws.ec2.getVpcOutput({ default: true });
const instance = new aws.ec2.Instance("web", {
    ami: vpcOutput.apply(v => v.id),
    // ...
});

Compute

EC2 (Elastic Compute Cloud)

Module: ec2

Query EC2 instances, AMIs, and networking components.

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

// Instances
ec2.getInstance({ instanceId });
ec2.getInstances({ filters, instanceTags });

// AMIs
ec2.getAmi({ filters, owners, mostRecent });
ec2.getAmiIds({ filters, owners });

// Launch templates
ec2.getLaunchTemplate({ name, id });

// VPCs and networking
ec2.getVpc({ id, default: true, filters });
ec2.getVpcs({ filters });
ec2.getSubnet({ id, filters });
ec2.getSubnets({ filters });
ec2.getSecurityGroup({ id, name, filters });
ec2.getSecurityGroups({ filters });
ec2.getRouteTable({ routeTableId, subnetId, filters });
ec2.getRouteTables({ filters });
ec2.getInternetGateway({ filters });
ec2.getNatGateway({ id, subnetId, filters });
ec2.getNatGateways({ filters });

// Networking details
ec2.getNetworkInterface({ id, filters });
ec2.getNetworkInterfaces({ filters });
ec2.getVpcPeeringConnection({ id, filters });
ec2.getVpcPeeringConnections({ filters });
ec2.getVpcEndpoint({ id, serviceName, filters });
ec2.getVpcEndpointService({ serviceName, filters });

// Availability zones
ec2.getAvailabilityZone({ name, zoneId });
ec2.getAvailabilityZones({ state, filters });

// IP addresses
ec2.getEip({ id, publicIp, filters });
ec2.getEips({ filters });

// Prefix lists
ec2.getManagedPrefixList({ id, name, filters });
ec2.getManagedPrefixLists({ filters });

// Capacity and placement
ec2.getCapacityReservation({ id, filters });
ec2.getInstanceType({ instanceType });
ec2.getInstanceTypes({ filters });
ec2.getInstanceTypeOffering({ filters });
ec2.getInstanceTypeOfferings({ filters });

// Snapshots and volumes
ec2.getSnapshot({ snapshotId, filters, mostRecent });
ec2.getSnapshotIds({ filters, owners });
ec2.getVolume({ filters, mostRecent });
ec2.getEbsVolumes({ filters });
ec2.getEbsEncryptionByDefault();
ec2.getEbsDefaultKmsKey();

// IPAM
ec2.getVpcIpamPool({ ipamPoolId, filters });
ec2.getVpcIpamPools({ filters });
ec2.getVpcIpamPreviewNextCidr({ ipamPoolId, filters });

// Coip pools
ec2.getCoipPool({ poolId, filters });
ec2.getCoipPools({ filters });

// Local gateways
ec2.getLocalGateway({ id, filters });
ec2.getLocalGateways({ filters });
ec2.getLocalGatewayRouteTable({ localGatewayRouteTableId, filters });
ec2.getLocalGatewayRouteTables({ filters });
ec2.getLocalGatewayVirtualInterface({ id, filters });
ec2.getLocalGatewayVirtualInterfaces({ filters });
ec2.getLocalGatewayVirtualInterfaceGroup({ id, filters });
ec2.getLocalGatewayVirtualInterfaceGroups({ filters });

Common Use Cases:

Find default VPC for resource deployment
Query latest AMI for instance creation
Reference existing security groups
Discover available subnets
Look up networking configuration

Full EC2 Documentation

Lambda

Module: lambda

Query Lambda functions and layers.

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

// Functions
lambda.getFunction({ functionName });
lambda.getFunctions({ filters });

// Layers
lambda.getLayerVersion({ layerName, version });

// Aliases and URLs
lambda.getAlias({ functionName, name });
lambda.getFunctionUrl({ functionName });

// Code signing
lambda.getCodeSigningConfig({ arn });

// Invocation
lambda.getInvocation({ functionName, input, qualifier });

Common Use Cases:

Reference existing Lambda functions
Get layer version ARNs
Query function configuration
Retrieve function URLs

ECS

Module: ecs

Query ECS clusters and services.

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

// Clusters
ecs.getCluster({ clusterName });
ecs.getClusters();

// Services
ecs.getService({ clusterArn, serviceName });

// Task definitions
ecs.getTaskDefinition({ taskDefinition });
ecs.getTaskExecution({ cluster, taskDefinition, networkConfiguration });

// Container definitions
ecs.getContainerDefinition({ taskDefinition, containerName });

Common Use Cases:

Reference existing ECS clusters
Query service configuration
Get task definition details
Validate container definitions

EKS

Module: eks

Query EKS clusters and node groups.

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

// Clusters
eks.getCluster({ name });
eks.getClusters();
eks.getClusterAuth({ name });
eks.getClusterVersions();

// Node groups
eks.getNodeGroup({ clusterName, nodeGroupName });
eks.getNodeGroups({ clusterName });

// Add-ons
eks.getAddon({ clusterName, addonName });
eks.getAddonVersion({ addonName, kubernetesVersion });

// Access
eks.getAccessEntry({ clusterName, principalArn });

Common Use Cases:

Get EKS cluster endpoint and certificate
Query authentication tokens
List available Kubernetes versions
Reference node groups
Discover add-on versions

Auto Scaling

Module: autoscaling

Query Auto Scaling Groups.

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

// Auto Scaling Groups
autoscaling.getGroup({ name });

// AMI IDs
autoscaling.getAmiIds({ filters });

Common Use Cases:

Reference existing Auto Scaling Groups
Query ASG configuration

Batch

Module: batch

Query Batch resources.

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

batch.getComputeEnvironment({ computeEnvironmentName });
batch.getJobDefinition({ name, revision, status });
batch.getJobQueue({ name });
batch.getSchedulingPolicy({ arn });

Common Use Cases:

Reference compute environments
Query job definitions
Get job queue configuration

Elastic Beanstalk

Module: elasticbeanstalk

Query Elastic Beanstalk resources.

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

elasticbeanstalk.getApplication({ name });
elasticbeanstalk.getHostedZone({ region });
elasticbeanstalk.getSolutionStack({ nameRegex, mostRecent });

Common Use Cases:

Reference existing applications
Get hosted zone for DNS
Find latest solution stacks

Storage

S3

Module: s3

Query S3 buckets and objects.

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

// Buckets
s3.getBucket({ bucket });
s3.getBuckets();

// Objects
s3.getBucketObject({ bucket, key });
s3.getBucketObjects({ bucket, prefix, delimiter });

// Access points
s3.getAccessPoint({ name, accountId });
s3.getAccessPoints({ bucket });

// Account settings
s3.getAccountPublicAccessBlock({ accountId });

// Canonical user ID
s3.getCanonicalUserId();

Common Use Cases:

Reference existing buckets
Query bucket configuration
List objects in a bucket
Get bucket ARN
Query access points

Full S3 Documentation

EBS

Module: ebs

Query EBS volumes and snapshots.

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

// Volumes
ebs.getVolume({ filters, mostRecent });
ebs.getEbsVolumes({ filters });

// Snapshots
ebs.getSnapshot({ snapshotId, filters, mostRecent, owners });
ebs.getSnapshotIds({ filters, owners });

// Encryption settings
ebs.getEncryptionByDefault();
ebs.getDefaultKmsKey();

Common Use Cases:

Find volumes by tag
Query snapshot details
Get default encryption settings
Reference existing volumes

Full EBS Documentation

EFS

Module: efs

Query EFS file systems.

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

// File systems
efs.getFileSystem({ fileSystemId, tags });

// Access points
efs.getAccessPoint({ accessPointId });
efs.getAccessPoints({ fileSystemId });

// Mount targets
efs.getMountTarget({ accessPointId, fileSystemId, mountTargetId });

Common Use Cases:

Reference existing file systems
Query mount target details
Get access point configuration
Find file systems by tags

Full EFS Documentation

FSx

Module: fsx

Query FSx file systems.

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

// Windows File Server
fsx.getWindowsFileSystem({ id });

// ONTAP
fsx.getOntapFileSystem({ id });
fsx.getOntapStorageVirtualMachine({ id, filters });
fsx.getOntapStorageVirtualMachines({ filters });

// OpenZFS
fsx.getOpenZfsSnapshot({ snapshotId, filters, mostRecent });

Common Use Cases:

Reference existing file systems
Query storage virtual machines
Get snapshot details

Backup

Module: backup

Query AWS Backup resources.

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

backup.getVault({ name });
backup.getPlan({ planId });
backup.getSelection({ planId, selectionId });
backup.getFramework({ name });
backup.getReportPlan({ name });

Common Use Cases:

Reference backup vaults
Query backup plans
Get backup selection details

Full Backup Documentation

Storage Gateway

Module: storagegateway

Query Storage Gateway resources.

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

storagegateway.getLocalDisk({ gatewayArn, diskNode, diskPath });

Common Use Cases:

Query local disk configuration

Database

RDS

Module: rds

Query RDS instances and clusters.

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

// Instances
rds.getInstance({ dbInstanceIdentifier, tags });
rds.getInstances({ filters, tags });

// Clusters
rds.getCluster({ clusterIdentifier, tags });
rds.getClusters({ filters });

// Snapshots
rds.getSnapshot({ dbInstanceIdentifier, dbSnapshotIdentifier, snapshotType, mostRecent });
rds.getClusterSnapshot({ dbClusterIdentifier, dbClusterSnapshotIdentifier, snapshotType, mostRecent });

// Engine versions
rds.getEngineVersion({ engine, version, parameterGroupFamily });
rds.getOrderableDbInstance({ engine, engineVersion, instanceClass, storageType, licenseModel });

// Configuration
rds.getSubnetGroup({ name });
rds.getParameterGroup({ name });
rds.getEventCategories({ sourceType });

// Proxy
rds.getProxy({ name });

// Certificates
rds.getCertificate({ id, latestValidTill });

// Reserved instances
rds.getReservedInstanceOffering({ dbInstanceClass, duration, multiAz, offeringType, productDescription });

Common Use Cases:

Reference existing database instances
Query cluster configuration
Find latest snapshots
Get engine version details
Query available instance classes

Full RDS Documentation

DynamoDB

Module: dynamodb

Query DynamoDB tables.

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

// Tables
dynamodb.getTable({ name });
dynamodb.getTables();

// Table items
dynamodb.getTableItem({ tableName, key });

Common Use Cases:

Reference existing tables
Query table configuration
Get table ARN and stream ARN
Retrieve specific items

Full DynamoDB Documentation

ElastiCache

Module: elasticache

Query ElastiCache clusters.

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

// Clusters
elasticache.getCluster({ clusterId });
elasticache.getReplicationGroup({ replicationGroupId });
elasticache.getServerlessCache({ serverlessCacheName });

// Configuration
elasticache.getSubnetGroup({ name });

// Users
elasticache.getUser({ userId });

// Reserved nodes
elasticache.getReservedCacheNodeOffering({ cacheNodeType, duration, offeringType, productDescription });

Common Use Cases:

Reference existing clusters
Query replication group details
Get cache endpoints
Query user configuration

Full ElastiCache Documentation

DocumentDB

Module: docdb

Query DocumentDB clusters.

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

docdb.getEngineVersion({ engine, version, parameterGroupFamily });
docdb.getOrderableDbInstance({ engine, engineVersion, instanceClass, licenseModel });

Common Use Cases:

Query engine versions
Get available instance classes

Neptune

Module: neptune

Query Neptune clusters.

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

neptune.getEngineVersion({ engine, version, parameterGroupFamily });
neptune.getOrderableDbInstance({ engine, engineVersion, instanceClass, licenseModel });

Common Use Cases:

Query engine versions
Get available instance classes

Redshift

Module: redshift

Query Redshift clusters.

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

redshift.getCluster({ clusterIdentifier, tags });
redshift.getSubnetGroup({ name });
redshift.getOrderableCluster({ clusterType, nodeType });
redshift.getServiceAccount({ region });
redshift.getDataShares({ filters });
redshift.getProducerDataShares({ filters });

Common Use Cases:

Reference existing clusters
Query cluster endpoints
Get service account for logging
Query data shares

Full Redshift Documentation

Redshift Serverless

Module: redshiftserverless

Query Redshift Serverless resources.

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

redshiftserverless.getNamespace({ namespaceName });
redshiftserverless.getWorkgroup({ workgroupName });
redshiftserverless.getCredentials({ workgroupName });

Common Use Cases:

Reference namespaces
Query workgroup details
Get temporary credentials

MemoryDB

Module: memorydb

Query MemoryDB resources.

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

memorydb.getCluster({ name, tags });
memorydb.getSubnetGroup({ name, tags });
memorydb.getParameterGroup({ name, tags });
memorydb.getSnapshot({ name, tags });
memorydb.getUser({ userName, tags });
memorydb.getAcl({ name, tags });

Common Use Cases:

Reference existing clusters
Query configuration
Get endpoint information

Timestream

Module: timestreamwrite

Query Timestream databases.

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

timestreamwrite.getDatabase({ databaseName });
timestreamwrite.getTable({ databaseName, tableName });

Common Use Cases:

Reference existing databases
Query table configuration

Networking

VPC

Module: ec2

See EC2 section above for VPC-related data sources.

Load Balancing

Module: lb, elb

Query load balancers and target groups.

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

// Application/Network Load Balancers
lb.getLoadBalancer({ name, arn, tags });
lb.getLbs({ tags });
lb.getListener({ loadBalancerArn, port, arn });
lb.getListenerRule({ listenerArn, arn });
lb.getTargetGroup({ name, arn, loadBalancerArn, tags });
lb.getTrustStore({ name, arn });
lb.getHostedZoneId({ region, loadBalancerType });

// Classic Load Balancers
elb.getLoadBalancer({ name });
elb.getServiceAccount({ region });
elb.getHostedZoneId({ region });

Common Use Cases:

Reference existing load balancers
Query listener configuration
Get target group ARNs
Find load balancer DNS names

Full Load Balancing Documentation

CloudFront

Module: cloudfront

Query CloudFront distributions.

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

// Distributions
cloudfront.getDistribution({ id });
cloudfront.getDistributionTenant({ id });

// Policies
cloudfront.getCachePolicy({ name, id });
cloudfront.getOriginRequestPolicy({ name, id });
cloudfront.getResponseHeadersPolicy({ name, id });

// Functions
cloudfront.getFunction({ name, stage });

// Origin access
cloudfront.getOriginAccessControl({ id });
cloudfront.getOriginAccessIdentity({ id });
cloudfront.getOriginAccessIdentities();

// Other
cloudfront.getLogDeliveryCanonicalUserId();
cloudfront.getRealtimeLogConfig({ name });
cloudfront.getConnectionGroup({ name });

Common Use Cases:

Reference existing distributions
Query cache policies
Get origin access identities
Find canonical user IDs

Full CloudFront Documentation

Route 53

Module: route53

Query DNS zones and records.

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

// Zones
route53.getZone({ name, zoneId, privateZone, vpcId, tags });

// Records
route53.getRecord({ hostedZoneId, name, type });

// Traffic policies
route53.getTrafficPolicy({ name, id, version });

// Resolvers
route53.getResolverEndpoint({ resolverId, filter });
route53.getResolverRule({ domainName, name, resolverId, ruleType });
route53.getResolverRules({ ownerId, resolverEndpointId, shareStatus });
route53.getResolverFirewallConfig({ resourceId });
route53.getResolverFirewallDomainList({ firewallDomainListId });
route53.getResolverFirewallRule({ firewallRuleGroupId, firewallDomainListId });
route53.getResolverFirewallRuleGroup({ firewallRuleGroupId });
route53.getResolverFirewallRuleGroups({ ownerId });
route53.getResolverQueryLogConfig({ name, resolverId, resolverQueryLogConfigId });
route53.getResolverQueryLogConfigAssociation({ resolverQueryLogConfigAssociationId, resolverId, filter });
route53.getResolverQueryLogConfigAssociations({ filters });

Common Use Cases:

Find hosted zone IDs
Query DNS records
Reference resolver endpoints
Get resolver rules

Full Route 53 Documentation

API Gateway

Module: apigateway, apigatewayv2

Query API Gateway resources.

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

// REST API (v1)
apigateway.getRestApi({ name });
apigateway.getResource({ restApiId, path });
apigateway.getDomainName({ domainName });
apigateway.getVpcLink({ name });
apigateway.getAuthorizer({ restApiId, authorizerId });
apigateway.getAuthorizers({ restApiId });
apigateway.getKey({ id });
apigateway.getApiKeys({ namePrefix });
apigateway.getExport({ restApiId, stageName, exportType });
apigateway.getSdk({ restApiId, stageName, sdkType });

// HTTP/WebSocket API (v2)
apigatewayv2.getApi({ apiId });
apigatewayv2.getApis({ name, protocolType, tags });
apigatewayv2.getVpcLink({ vpcLinkId });
apigatewayv2.getExport({ apiId, specification, outputType });

Common Use Cases:

Reference existing APIs
Query API configuration
Get API endpoints
Export API definitions

Full API Gateway Documentation

VPC Lattice

Module: vpclattice

Query VPC Lattice resources.

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

vpclattice.getService({ serviceIdentifier, tags });
vpclattice.getServiceNetwork({ serviceNetworkIdentifier, tags });
vpclattice.getListener({ listenerIdentifier, serviceIdentifier, tags });
vpclattice.getAuthPolicy({ resourceIdentifier });
vpclattice.getResourceConfiguration({ resourceConfigurationIdentifier });
vpclattice.getResourceGateway({ resourceGatewayIdentifier });

Common Use Cases:

Reference existing services
Query service networks
Get listener configuration

Direct Connect

Module: directconnect

Query Direct Connect resources.

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

directconnect.getConnection({ name });
directconnect.getGateway({ name });
directconnect.getLocation({ locationCode });
directconnect.getLocations();
directconnect.getRouterConfiguration({ routerTypeIdentifier, virtualInterfaceId });

Common Use Cases:

Reference existing connections
Query gateway configuration
List available locations

Transit Gateway

Module: ec2transitgateway

Query Transit Gateway resources.

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

ec2transitgateway.getTransitGateway({ id, filter });
ec2transitgateway.getAttachment({ transitGatewayAttachmentId, filter });
ec2transitgateway.getAttachments({ filter });
ec2transitgateway.getRouteTable({ id, filter });
ec2transitgateway.getRouteTables({ filter });
ec2transitgateway.getVpcAttachment({ id, filter });
ec2transitgateway.getVpcAttachments({ filter });
ec2transitgateway.getConnect({ transitGatewayConnectId, filter });
ec2transitgateway.getConnects({ filter });
ec2transitgateway.getConnectPeer({ transitGatewayConnectPeerId, filter });
ec2transitgateway.getPeeringAttachment({ id, filter });
ec2transitgateway.getDirectConnectGatewayAttachment({ transitGatewayId, dxGatewayId, filter });
ec2transitgateway.getMulticastDomain({ transitGatewayMulticastDomainId, filter });

Common Use Cases:

Reference Transit Gateways
Query attachments
Get route table details

Global Accelerator

Module: globalaccelerator

Query Global Accelerator resources.

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

globalaccelerator.getAccelerator({ name, arn, tags });
globalaccelerator.getCustomRoutingAccelerator({ name, arn, tags });

Common Use Cases:

Reference existing accelerators
Query accelerator configuration

Client VPN

Module: ec2clientvpn

Query Client VPN endpoints.

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

ec2clientvpn.getEndpoint({ clientVpnEndpointId, filter, tags });

Common Use Cases:

Reference VPN endpoints
Query endpoint configuration

Security & Identity

IAM

Module: iam

Query IAM resources.

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

// Users and groups
iam.getUser({ userName });
iam.getUsers({ nameRegex, pathPrefix });
iam.getGroup({ groupName });
iam.getAccountAlias();

// Roles
iam.getRole({ name });
iam.getRoles({ nameRegex, pathPrefix });

// Policies
iam.getPolicy({ name, pathPrefix, arn });
iam.getPolicies({ pathPrefix });
iam.getPolicyDocument({ statements, sourceJson, sourcePolicyDocuments, overrideJson, overridePolicyDocuments });

// Instance profiles
iam.getInstanceProfile({ name });
iam.getInstanceProfiles({ roleArn });

// Identity providers
iam.getOpenIdConnectProvider({ arn, url });
iam.getSamlProvider({ arn });

// Server certificates
iam.getServerCertificate({ name, latest, pathPrefix });

// Session context
iam.getSessionContext({ arn });

// Principal info
iam.getPrincipalPolicySimulation({ policySourceArn, actionNames, resourceArns });

Common Use Cases:

Reference existing roles
Generate policy documents
Query user and group information
Get instance profile ARNs
Find server certificates

Full IAM Documentation

KMS

Module: kms

Query KMS keys.

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

// Keys
kms.getKey({ keyId, grantTokens });
kms.getPublicKey({ keyId, grantTokens });

// Aliases
kms.getAlias({ name });

// Secrets (deprecated - use Secrets Manager)
kms.getSecret({ name });
kms.getSecrets({ secrets });

// Cipher text
kms.getCipherText({ keyId, plaintext, context });

// Custom key stores
kms.getCustomKeyStore({ customKeyStoreId, customKeyStoreName });

Common Use Cases:

Reference existing keys by alias
Get key metadata
Retrieve public keys
Encrypt data

Full KMS Documentation

Secrets Manager

Module: secretsmanager

Query secrets.

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

secretsmanager.getSecret({ name, arn });
secretsmanager.getSecrets({ filters });
secretsmanager.getSecretVersion({ secretId, versionId, versionStage });
secretsmanager.getSecretVersions({ secretId });
secretsmanager.getSecretRotation({ secretId });
secretsmanager.getRandomPassword({ length, excludeCharacters, excludeLowercase, excludeNumbers, excludePunctuation, excludeUppercase, includeSpace, requireEachIncludedType });

Common Use Cases:

Retrieve secret values
Query secret metadata
Get specific versions
Generate random passwords

Full Secrets Manager Documentation

ACM

Module: acm

Query certificates.

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

acm.getCertificate({ domain, statuses, types, mostRecent, keyTypes });

Common Use Cases:

Find certificates by domain
Get certificate ARNs
Query certificate status

Security Hub

Module: securityhub

Query Security Hub resources.

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

securityhub.getStandardsControlAssociations({ securityControlId });

Common Use Cases:

Query standards control associations

Full Security Hub Documentation

GuardDuty

Module: guardduty

Query GuardDuty resources.

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

guardduty.getDetector({ id });
guardduty.getFindingIds({ detectorId, findingCriteria });

Common Use Cases:

Reference detector IDs
Query findings

Full GuardDuty Documentation

WAF

Module: waf, wafregional, wafv2

Query WAF resources.

import { waf, wafregional, wafv2 } from "@pulumi/aws";

// WAF Classic
waf.getWebAcl({ name });
waf.getRule({ name });
waf.getIpSet({ name });
waf.getRateBasedRule({ name });
waf.getSubscribedRuleGroup({ name, metricName });

// WAF Regional
wafregional.getWebAcl({ name });
wafregional.getRule({ name });
wafregional.getIpSet({ name });
wafregional.getRateBasedRule({ name });
wafregional.getSubscribedRuleGroup({ name, metricName });

// WAF v2
wafv2.getWebAcl({ name, scope });
wafv2.getRuleGroup({ name, scope });
wafv2.getIpSet({ name, scope });
wafv2.getRegexPatternSet({ name, scope });

Common Use Cases:

Reference existing WAFs
Query rule configurations
Get IP set details

Full WAF Documentation

Shield

Module: shield

Query Shield protections.

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

shield.getProtection({ resourceArn, protectionId });

Common Use Cases:

Query protection status

Cognito

Module: cognito

Query Cognito resources.

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

// User pools
cognito.getUserPool({ userPoolId });
cognito.getUserPools({ name });
cognito.getUserPoolClient({ clientId, userPoolId });
cognito.getUserPoolClients({ userPoolId });
cognito.getUserGroup({ name, userPoolId });
cognito.getUserGroups({ userPoolId });
cognito.getUserPoolSigningCertificate({ userPoolId });

// Identity pools
cognito.getIdentityPool({ identityPoolName });

Common Use Cases:

Reference user pools
Query client configurations
Get signing certificates
Find identity pools

Management

CloudWatch

Module: cloudwatch

Query CloudWatch resources.

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

// Log groups
cloudwatch.getLogGroup({ name });
cloudwatch.getLogGroups({ logGroupNamePrefix });

// Events
cloudwatch.getEventBus({ name });
cloudwatch.getEventBuses({ namePrefix });
cloudwatch.getEventSource({ namePrefix });
cloudwatch.getEventConnection({ name });

// Log data protection
cloudwatch.getLogDataProtectionPolicyDocument({ name, description, version, statement });

// Contributor insights
cloudwatch.getContributorManagedInsightRules({ namePrefix });

Common Use Cases:

Reference log groups
Query event buses
Get log group ARNs

Full CloudWatch Documentation

CloudTrail

Module: cloudtrail

Query CloudTrail resources.

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

cloudtrail.getServiceAccount({ region });

Common Use Cases:

Get service account for S3 bucket policies

SSM (Systems Manager)

Module: ssm

Query SSM parameters and documents.

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

// Parameters
ssm.getParameter({ name, withDecryption });
ssm.getParameters({ names, withDecryption });
ssm.getParametersByPath({ path, recursive, withDecryption });

// Documents
ssm.getDocument({ name, documentFormat, documentVersion });

// Patch baselines
ssm.getPatchBaseline({ owner, namePrefix, operatingSystem, defaultBaseline });
ssm.getPatchBaselines({ filters });

// Maintenance windows
ssm.getMaintenanceWindow({ name });

// Instances
ssm.getInstances({ filters });

Common Use Cases:

Retrieve parameter values
Query SSM documents
Get patch baselines
Reference maintenance windows

Organizations

Module: organizations

Query AWS Organizations resources.

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

organizations.getOrganization();
organizations.getOrganizationalUnit({ name, parentId });
organizations.getOrganizationalUnits({ parentId });
organizations.getOrganizationalUnitChildAccounts({ parentId });
organizations.getOrganizationalUnitDescendantAccounts({ parentId });
organizations.getOrganizationalUnitsForParent({ parentId });
organizations.getPolicy({ policyId });
organizations.getDelegatedAdministrator({ servicePrincipal });
organizations.getDelegatedServices({ accountId });
organizations.getResourceTags({ resourceId });

Common Use Cases:

Query organization structure
Get organizational unit details
Reference policies
Query delegated administrators

Service Catalog

Module: servicecatalog

Query Service Catalog resources.

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

servicecatalog.getPortfolio({ id });
servicecatalog.getProduct({ id, acceptLanguage });
servicecatalog.getLaunchPaths({ productId, acceptLanguage });
servicecatalog.getConstraint({ id, acceptLanguage });
servicecatalog.getProvisioningArtifacts({ productId, acceptLanguage });
servicecatalog.getPortfolioConstraints({ portfolioId, productId, acceptLanguage });

Common Use Cases:

Reference portfolios
Query products
Get launch paths
Query constraints

CloudFormation

Module: cloudformation

Query CloudFormation resources.

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

cloudformation.getStack({ name });
cloudformation.getExport({ name });
cloudformation.getCloudFormationType({ arn, type, typeName, versionId });

Common Use Cases:

Query stack outputs
Reference exported values
Get stack details

Analytics

Athena

Module: athena

Query Athena resources.

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

athena.getNamedQuery({ name, workgroup });

Common Use Cases:

Reference named queries

Glue

Module: glue

Query Glue resources.

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

glue.getCatalogTable({ databaseName, name });
glue.getConnection({ id });
glue.getDataCatalogEncryptionSettings({ catalogId });
glue.getRegistry({ name });
glue.getScript({ dagEdge, dagNode, language });

Common Use Cases:

Reference catalog tables
Query connections
Get encryption settings
Generate ETL scripts

MSK

Module: msk

Query MSK resources.

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

msk.getCluster({ clusterName });
msk.getBrokerNodes({ clusterArn });
msk.getConfiguration({ name });
msk.getKafkaVersion({ version });
msk.getVpcConnection({ arn });

Common Use Cases:

Reference clusters
Query broker endpoints
Get configurations

MSK Connect

Module: mskconnect

Query MSK Connect resources.

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

mskconnect.getConnector({ name });
mskconnect.getCustomPlugin({ name });
mskconnect.getWorkerConfiguration({ name });

Common Use Cases:

Reference connectors
Query custom plugins
Get worker configurations

OpenSearch

Module: opensearch

Query OpenSearch resources.

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

opensearch.getDomain({ domainName, tags });
opensearch.getDomainDataSource({ domainName, name });
opensearch.getServerlessCollection({ name, id });
opensearch.getServerlessSecurityPolicy({ name, type });
opensearch.getAccessPolicy({ name, type });

Common Use Cases:

Reference domains
Query endpoint URLs
Get serverless collections

QuickSight

Module: quicksight

Query QuickSight resources.

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

quicksight.getDataSet({ dataSetId, awsAccountId, tags });
quicksight.getQuicksightAnalysis({ analysisId, awsAccountId, tags });
quicksight.getQuicksightGroup({ groupName, awsAccountId, namespace });
quicksight.getQuicksightUser({ userName, awsAccountId, namespace });
quicksight.getTheme({ themeId, awsAccountId, tags });

Common Use Cases:

Reference datasets
Query analysis details
Get user and group information

Lake Formation

Module: lakeformation

Query Lake Formation resources.

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

lakeformation.getDataLakeSettings({ catalogId });
lakeformation.getPermissions({ principal, catalogResource, database, table, dataLocation });
lakeformation.getResource({ arn });

Common Use Cases:

Query data lake settings
Get resource permissions
Reference registered resources

Application Integration

SNS

Module: sns

Query SNS topics.

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

sns.getTopic({ name });

Common Use Cases:

Reference existing topics
Get topic ARNs

Full SNS Documentation

SQS

Module: sqs

Query SQS queues.

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

sqs.getQueue({ name, tags });
sqs.getQueues({ queueNamePrefix });

Common Use Cases:

Reference existing queues
Get queue URLs and ARNs

Full SQS Documentation

Step Functions

Module: sfn

Query Step Functions resources.

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

sfn.getStateMachine({ name });
sfn.getStateMachineVersions({ statemachineArn });
sfn.getActivity({ name });
sfn.getAlias({ name, statemachineArn });

Common Use Cases:

Reference state machines
Query versions
Get activity ARNs

AppIntegrations

Module: appintegrations

Query AppIntegrations resources.

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

appintegrations.getEventIntegration({ name });

Common Use Cases:

Reference event integrations

Containers

ECR

Module: ecr

Query ECR repositories.

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

ecr.getRepository({ name, registryId });
ecr.getRepositories({ repositoryNames });
ecr.getAuthorizationToken({ registryId });
ecr.getImage({ repositoryName, imageTag, imageDigest, registryId });
ecr.getImages({ repositoryName, filters });
ecr.getLifecyclePolicyDocument({ rules });
ecr.getPullThroughCacheRule({ ecrRepositoryPrefix });
ecr.getRepositoryCreationTemplate({ prefix, appliedFor, repositoryType });

Common Use Cases:

Reference repositories
Get authorization tokens
Query images
Get repository URLs

ECR Public

Module: ecrpublic

Query ECR Public repositories.

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

ecrpublic.getAuthorizationToken();
ecrpublic.getImages({ repositoryName, filters });

Common Use Cases:

Get authorization tokens
Query public images

Pricing

Module: pricing

Query AWS service pricing.

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

pricing.getProduct({ filters, serviceCode });

Common Use Cases:

Query pricing information
Get service pricing details

Other Services

App Runner

Module: apprunner

Query App Runner resources.

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

apprunner.getHostedZoneId({ region });

Common Use Cases:

Get hosted zone ID for DNS

AppStream

Module: appstream

Query AppStream resources.

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

appstream.getImage({ name, type, mostRecent, nameRegex });

Common Use Cases:

Query available images

Billing

Module: billing

Query billing resources.

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

billing.getViews();

Common Use Cases:

Query billing views

Budgets

Module: budgets

Query AWS Budgets.

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

budgets.getBudget({ name, accountId });

Common Use Cases:

Query budget details

Cost Explorer

Module: costexplorer

Query Cost Explorer resources.

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

costexplorer.getCostCategory({ name, effectiveOn });
costexplorer.getTags({ timePeriod, filter, searchString, sortBy, maxResults });

Common Use Cases:

Query cost categories
Get cost allocation tags

Service Discovery

Module: servicediscovery

Query Service Discovery resources.

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

servicediscovery.getDnsNamespace({ name, type });
servicediscovery.getHttpNamespace({ name });
servicediscovery.getService({ name, namespaceId, tags });

Common Use Cases:

Reference namespaces
Query services

tessl/npm-pulumi--aws

data-sources.md.css-3qkkll{font-size:var(--chakra-font-sizes-sm);font-weight:var(--chakra-font-weights-normal);color:var(--chakra-colors-gray-300);}docs/reference/

AWS Data Sources by Category

Quick Navigation

Overview

Usage Pattern

Compute

EC2 (Elastic Compute Cloud)

Lambda

ECS

EKS

Auto Scaling

Batch

Elastic Beanstalk

Storage

S3

EBS

EFS

FSx

Backup

Storage Gateway

Database

RDS

DynamoDB

ElastiCache

DocumentDB

Neptune

Redshift

Redshift Serverless

MemoryDB

Timestream

Networking

VPC

Load Balancing

CloudFront

Route 53

API Gateway

VPC Lattice

Direct Connect

Transit Gateway

Global Accelerator

Client VPN

Security & Identity

IAM

KMS

Secrets Manager

ACM

Security Hub

GuardDuty

WAF

Shield

Cognito

Management

CloudWatch

CloudTrail

SSM (Systems Manager)

Organizations

Service Catalog

CloudFormation

Analytics

Athena

Glue

MSK

MSK Connect

OpenSearch

QuickSight

Lake Formation

Application Integration

SNS

SQS

Step Functions

AppIntegrations

Containers

ECR

ECR Public

Pricing

Pricing

Other Services

App Runner

AppStream

data-sources.mddocs/reference/