القائمة
Use when building reusable infrastructure components with Pulumi for modular, composable cloud resources.
يُحدَّد Prompt الذي يراجع المصدر أولًا بشكل افتراضي. يمكنك التبديل إلى أمر مباشر أو تنزيل نسخة محلية.
اقرأ SKILL.md وأي ملفات مرافقة يعرضها SkillsMP قبل أن تقرر التثبيت.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
يتجاوز الأمر المباشر Prompt المخصّص للمراجعة. افحص المصدر قبل تشغيله.
npx skills add https://github.com/TheBushidoCollective/han --skill pulumi-componentsيبقى الأمر في سطر واحد. مرّر أفقيًا لمراجعته كاملًا قبل النسخ.
تفضّل نسخة محلية؟ نزّل الملفات المتاحة حاليًا لدى SkillsMP.
Review current branch changes against REVIEW.md guidelines
Use when kotlin coroutines for structured concurrency including suspend functions, coroutine builders, Flow, channels, and patterns for building efficient asynchronous code with cancellation and exception handling.
Use when building modular Angular applications requiring dependency injection with providers, injectors, and services.
استنادا إلى تصنيف SOC المهني
عرض SKILL.md
| name | pulumi-components |
| user-invocable | false |
| description | Use when building reusable infrastructure components with Pulumi for modular, composable cloud resources. |
| allowed-tools | ["Bash","Read"] |
Build reusable infrastructure components with Pulumi to create modular, composable, and maintainable infrastructure.
Pulumi ComponentResources allow you to create higher-level abstractions that encapsulate multiple cloud resources into logical units. This enables code reuse, better organization, and more maintainable infrastructure code.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
export interface WebServerArgs {
instanceType?: pulumi.Input<string>;
ami?: pulumi.Input<string>;
subnetId: pulumi.Input<string>;
vpcId: pulumi.Input<string>;
}
export class WebServer extends pulumi.ComponentResource {
public readonly instance: aws.ec2.Instance;
public readonly securityGroup: aws.ec2.SecurityGroup;
public readonly publicIp: pulumi.Output<string>;
constructor(name: string, args: WebServerArgs, opts?: pulumi.ComponentResourceOptions) {
super("custom:infrastructure:WebServer", name, {}, opts);
const defaultOpts = { parent: this };
// Create security group
this.securityGroup = new aws.ec2.SecurityGroup(`${name}-sg`, {
vpcId: args.vpcId,
description: "Security group for web server",
ingress: [
{
protocol: "tcp",
fromPort: 80,
toPort: 80,
cidrBlocks: ["0.0.0.0/0"],
},
{
protocol: "tcp",
fromPort: 443,
toPort: 443,
cidrBlocks: ["0.0.0.0/0"],
},
],
egress: [{
protocol: "-1",
fromPort: 0,
toPort: 0,
cidrBlocks: ["0.0.0.0/0"],
}],
tags: {
Name: `${name}-sg`,
},
}, defaultOpts);
// Create EC2 instance
this.instance = new aws.ec2.Instance(`${name}-instance`, {
instanceType: args.instanceType || "t3.micro",
ami: args.ami,
subnetId: args.subnetId,
vpcSecurityGroupIds: [this.securityGroup.id],
tags: {
Name: `${name}-instance`,
},
}, defaultOpts);
this.publicIp = this.instance.publicIp;
this.registerOutputs({
instance: this.instance,
securityGroup: this.securityGroup,
publicIp: this.publicIp,
});
}
}
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
export interface VpcNetworkArgs {
cidrBlock?: string;
availabilityZones?: string[];
enableNatGateway?: boolean;
enableVpnGateway?: boolean;
enableDnsHostnames?: boolean;
enableDnsSupport?: boolean;
privateSubnetCidrs?: string[];
publicSubnetCidrs?: string[];
tags?: { [key: string]: string };
}
export class VpcNetwork extends pulumi.ComponentResource {
public readonly vpc: aws.ec2.Vpc;
public readonly publicSubnets: aws.ec2.Subnet[];
public readonly privateSubnets: aws.ec2.Subnet[];
public readonly : aws..;
?: aws..[];
: aws..;
: aws..[];
: pulumi.<>;
() {
(, name, {}, opts);
defaultOpts = { : };
cidrBlock = args. || ;
azs = args. || [, ];
publicCidrs = args. || [, ];
privateCidrs = args. || [, ];
. = aws..(, {
: cidrBlock,
: args. !== ,
: args. !== ,
: {
: ,
...args.,
},
}, defaultOpts);
. = ..;
. = aws..(, {
: ..,
: {
: ,
...args.,
},
}, defaultOpts);
. = [];
( i = ; i < azs.; i++) {
subnet = aws..(, {
: ..,
: publicCidrs[i],
: azs[i],
: ,
: {
: ,
: ,
...args.,
},
}, defaultOpts);
..(subnet);
}
. = [];
( i = ; i < azs.; i++) {
subnet = aws..(, {
: ..,
: privateCidrs[i],
: azs[i],
: {
: ,
: ,
...args.,
},
}, defaultOpts);
..(subnet);
}
. = aws..(, {
: ..,
: {
: ,
...args.,
},
}, defaultOpts);
aws..(, {
: ..,
: ,
: ..,
}, defaultOpts);
..( {
aws..(, {
: subnet.,
: ..,
}, defaultOpts);
});
(args. !== ) {
. = [];
..( {
eip = aws..(, {
: ,
: {
: ,
...args.,
},
}, defaultOpts);
natGw = aws..(, {
: subnet.,
: eip.,
: {
: ,
...args.,
},
}, defaultOpts);
..(natGw);
});
}
. = [];
..( {
rt = aws..(, {
: ..,
: {
: ,
...args.,
},
}, defaultOpts);
(. && .[i]) {
aws..(, {
: rt.,
: ,
: .[i].,
}, defaultOpts);
}
aws..(, {
: subnet.,
: rt.,
}, defaultOpts);
..(rt);
});
.({
: .,
: .,
: .,
: .,
: .,
: .,
});
}
}
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
export interface DatabaseArgs {
engine: "postgres" | "mysql" | "mariadb";
engineVersion: string;
instanceClass?: string;
allocatedStorage?: number;
databaseName: string;
username: string;
password: pulumi.Input<string>;
vpcId: pulumi.Input<string>;
subnetIds: pulumi.Input<string>[];
backupRetentionPeriod?: number;
multiAz?: boolean;
allowedSecurityGroupIds?: pulumi.Input<string>[];
allowedCidrBlocks?: string[];
}
export class Database extends pulumi.ComponentResource {
public readonly instance: aws.rds.Instance;
: aws..;
: aws..;
: pulumi.<>;
: pulumi.<>;
() {
(, name, {}, opts);
defaultOpts = { : };
. = aws..(, {
: args.,
: {
: ,
},
}, defaultOpts);
. = aws..(, {
: args.,
: ,
: {
: ,
},
}, defaultOpts);
portMap = {
: ,
: ,
: ,
};
dbPort = portMap[args.];
(args.) {
args..( {
aws..(, {
: ,
: dbPort,
: dbPort,
: ,
: sgId,
: ..,
}, defaultOpts);
});
}
(args.) {
aws..(, {
: ,
: dbPort,
: dbPort,
: ,
: args.,
: ..,
}, defaultOpts);
}
. = aws..(, {
: args.,
: args.,
: args. || ,
: args. || ,
: args.,
: args.,
: args.,
: ..,
: [..],
: args. || ,
: args. || ,
: ,
: {
: ,
},
}, defaultOpts);
. = ..;
. = ..;
.({
: .,
: .,
: .,
});
}
}
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
export interface ContainerAppArgs {
vpcId: pulumi.Input<string>;
publicSubnetIds: pulumi.Input<string>[];
privateSubnetIds: pulumi.Input<string>[];
containerImage: string;
containerPort: number;
cpu?: number;
memory?: number;
desiredCount?: number;
environment?: { [key: string]: string };
secrets?: { [key: string]: pulumi.Input<string> };
}
export class ContainerApp extends pulumi.ComponentResource {
public readonly cluster: aws.ecs.Cluster;
public readonly taskDefinition: aws.ecs.;
: aws..;
: aws..;
: aws..;
: pulumi.<>;
() {
(, name, {}, opts);
defaultOpts = { : };
. = aws..(, {
: {
: ,
},
}, defaultOpts);
albSg = aws..(, {
: args.,
: ,
: [
{
: ,
: ,
: ,
: [],
},
{
: ,
: ,
: ,
: [],
},
],
: [{
: ,
: ,
: ,
: [],
}],
: {
: ,
},
}, defaultOpts);
. = aws..(, {
: ,
: ,
: [albSg.],
: args.,
: {
: ,
},
}, defaultOpts);
. = aws..(, {
: args.,
: ,
: args.,
: ,
: {
: ,
: ,
: ,
: ,
: ,
: ,
},
: {
: ,
},
}, defaultOpts);
aws..(, {
: ..,
: ,
: ,
: [{
: ,
: ..,
}],
}, defaultOpts);
taskExecRole = aws..(, {
: aws..({
: ,
}),
: {
: ,
},
}, defaultOpts);
aws..(, {
: taskExecRole.,
: ,
}, defaultOpts);
envVars = .(args. || {}).( ({
name,
value,
}));
secretVars = .(args. || {}).( ({
name,
valueFrom,
}));
containerDef = pulumi.([
pulumi.(args.),
pulumi.(args.),
]).( .([{
: ,
: image,
: args. || ,
: args. || ,
: ,
: [{
: port,
: ,
}],
: envVars,
: secretVars. > ? secretVars : ,
: {
: ,
: {
: ,
: aws.().( r.),
: ,
},
},
}]));
aws..(, {
: ,
: ,
: {
: ,
},
}, defaultOpts);
. = aws..(, {
: name,
: (args. || ),
: (args. || ),
: ,
: [],
: taskExecRole.,
: containerDef,
: {
: ,
},
}, defaultOpts);
serviceSg = aws..(, {
: args.,
: ,
: [{
: ,
: args.,
: args.,
: [albSg.],
}],
: [{
: ,
: ,
: ,
: [],
}],
: {
: ,
},
}, defaultOpts);
. = aws..(, {
: ..,
: ..,
: args. || ,
: ,
: {
: args.,
: [serviceSg.],
: ,
},
: [{
: ..,
: ,
: args.,
}],
: {
: ,
},
}, defaultOpts);
. = ..;
.({
: .,
: .,
: .,
});
}
}
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
export interface StaticWebsiteArgs {
domainName?: string;
indexDocument?: string;
errorDocument?: string;
enableCdn?: boolean;
certificateArn?: pulumi.Input<string>;
}
export class StaticWebsite extends pulumi.ComponentResource {
public readonly bucket: aws.s3.Bucket;
public readonly bucketPolicy: aws.s3.BucketPolicy;
public readonly distribution?: aws.cloudfront.Distribution;
public readonly websiteUrl: pulumi.Output<string>;
constructor(name: string, args: StaticWebsiteArgs, ?: pulumi.) {
(, name, {}, opts);
defaultOpts = { : };
. = aws..(, {
: args. || ,
: {
: args. || ,
: args. || ,
},
: {
: ,
},
}, defaultOpts);
aws..(, {
: ..,
: args. !== ,
: args. !== ,
: args. !== ,
: args. !== ,
}, defaultOpts);
(args. !== ) {
oai = aws..(, {
: ,
}, defaultOpts);
. = aws..(, {
: ..,
: pulumi.([.., oai.]).(
.({
: ,
: [{
: ,
: {
: oaiArn,
},
: ,
: ,
}],
})
),
}, defaultOpts);
. = aws..(, {
: ,
: args. || ,
: [{
: ,
: ..,
: {
: oai.,
},
}],
: {
: ,
: ,
: [, , ],
: [, ],
: ,
: {
: ,
: {
: ,
},
},
: ,
: ,
: ,
},
: {
: {
: ,
},
},
: args. ? {
: args.,
: ,
: ,
} : {
: ,
},
: args. ? [args.] : ,
: [{
: ,
: ,
: ,
}],
: {
: ,
},
}, defaultOpts);
. = ...( );
} {
. = aws..(, {
: ..,
: ...(
.({
: ,
: [{
: ,
: ,
: ,
: ,
}],
})
),
}, defaultOpts);
. = ...( );
}
.({
: .,
: .,
: .,
});
}
}
import * as pulumi from "@pulumi/pulumi";
import * as k8s from "@pulumi/kubernetes";
export interface K8sAppArgs {
namespace?: string;
image: string;
replicas?: number;
port: number;
resources?: {
requests?: {
memory?: string;
cpu?: string;
};
limits?: {
memory?: string;
cpu?: string;
};
};
environment?: { [key: string]: string };
secrets?: { [key: string]: string };
enableIngress?: boolean;
ingressHost?: string;
}
export class K8sApp extends pulumi.ComponentResource {
public readonly namespace: k8s.core.v1.Namespace;
public : k8s...;
: k8s...;
?: k8s...;
?: k8s...;
?: k8s...;
() {
(, name, {}, opts);
defaultOpts = { : };
ns = args. || ;
(args. && args. !== ) {
. = k8s...(, {
: {
: args.,
},
}, defaultOpts);
}
(args. && .(args.). > ) {
. = k8s...(, {
: {
: ,
: ns,
},
: args.,
}, defaultOpts);
}
(args. && .(args.). > ) {
. = k8s...(, {
: {
: ,
: ns,
},
: args.,
}, defaultOpts);
}
: [] = [];
(.) {
.(args. || {}).( {
envVars.({
: key,
: {
: {
: ,
: key,
},
},
});
});
}
(.) {
.(args. || {}).( {
envVars.({
: key,
: {
: {
: ,
: key,
},
},
});
});
}
. = k8s...(, {
: {
: ,
: ns,
: {
: name,
},
},
: {
: args. || ,
: {
: {
: name,
},
},
: {
: {
: {
: name,
},
},
: {
: [{
: name,
: args.,
: [{
: args.,
}],
: envVars. > ? envVars : ,
: args.,
: {
: {
: ,
: args.,
},
: ,
: ,
},
: {
: {
: ,
: args.,
},
: ,
: ,
},
}],
},
},
},
}, defaultOpts);
. = k8s...(, {
: {
: ,
: ns,
: {
: name,
},
},
: {
: {
: name,
},
: [{
: ,
: args.,
: ,
}],
: args. ? : ,
},
}, defaultOpts);
(args. && args.) {
. = k8s...(, {
: {
: ,
: ns,
: {
: ,
: ,
},
},
: {
: [{
: [args.],
: ,
}],
: [{
: args.,
: {
: [{
: ,
: ,
: {
: {
: ,
: {
: ,
},
},
},
}],
},
}],
},
}, defaultOpts);
}
.({
: .,
: .,
: .,
});
}
}
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
export interface LambdaFunctionArgs {
runtime: aws.lambda.Runtime;
handler: string;
code: pulumi.asset.AssetArchive | pulumi.asset.FileArchive;
environment?: { [key: string]: string };
timeout?: number;
memorySize?: number;
vpcConfig?: {
subnetIds: pulumi.Input<string>[];
securityGroupIds: pulumi.Input<string>[];
};
policies?: pulumi.Input<string>[];
layers?: pulumi.Input<string>[];
}
export class LambdaFunction extends pulumi.ComponentResource {
public readonly function: aws.lambda.Function;
: aws..;
: aws..;
: pulumi.<>;
() {
(, name, {}, opts);
defaultOpts = { : };
. = aws..(, {
: aws..({
: ,
}),
: {
: ,
},
}, defaultOpts);
aws..(, {
: ..,
: ,
}, defaultOpts);
(args.) {
aws..(, {
: ..,
: ,
}, defaultOpts);
}
(args.) {
args..( {
aws..(, {
: ..,
: policyArn,
}, defaultOpts);
});
}
. = aws..(, {
: ,
: ,
: {
: ,
},
}, defaultOpts);
. = aws..(, {
: args.,
: args.,
: args.,
: ..,
: args. || ,
: args. || ,
: args. ? {
: args.,
} : ,
: args.,
: args.,
: {
: ,
},
}, defaultOpts);
. = ..;
.({
: .,
: .,
});
}
}
Use the pulumi-components skill when you need to:
{ parent: this } when creating child resources to maintain proper resource hierarchyregisterOutputs() at the end of constructor to expose component propertiespulumi.Input<T> for arguments that can be outputs from other resourcesdefaultOpts object with parent set for all child resourcesparent: this breaks resource hierarchy and prevents proper deletionregisterOutputs() prevents output trackingcategory:subcategory:Name)pulumi.Output.apply() for dependent values