serverlessrepo-application-deployer
Provisions AWS Serverless Application Repository (SAR) applications with production defaults: SAM template (template.yaml) with Transform: AWS::Serverless-2016-10-31, README.md (required for publish), LICENSE (required for public), application packaging (zip upload or S3 bucket with code URI), semantic versioning (SemVer — required for every publish), application sharing model (private vs account-grant vs public), application policy (who can deploy cross-account), nested applications (AWS::Serverless:: Application), application parameters (cloudformation parameters surfaced at deploy time), deployment role (CAPABILITY_IAM / CAPABILITY_NAMED_IAM / CAPABILITY_AUTO_EXPAND), SAM transform during deploy (transform happens BEFORE CloudFormation sees the template), published author profile (author name, URL. Triggers: publish serverless application, sar publish, serverless application repository, sam package, sam deploy, sar application policy, cross-account sar deploy, nested sar application, semantic version sar.
- License 许可
- Apache-2.0
- 最近更新
- 2026-09-24
- Stars
- ★ 4
- Forks
- 0
01 前言 Front Matter
- name
- serverlessrepo-application-deployer
- license
- Apache-2.0
- metadata
- { "tags": "aws, serverless, sar, sam, cloudformation, cloudops, deploy, devtools, semantic-versioning, application-policy, nested-application, cross-account", "phase": "1", "author": "Jacky Chan — AWS Community Builder", "domain": "aws-cloudops", "family": "DevTools", "version": "0.1.0", "keywords": "aws, serverless application repository, sar, sam, sam template, sam deploy, sam package, cloudformation, semantic versioning, application policy, nested application, cross-account deploy, application sharing, public application, private application, appregistry, deployment role, lambda, cloudops, deploy, devtools", "task_type": "deploy", "complexity": "high", "entry_point": "false", "skill_class": "capability", "when_to_use": "Invoke when the user wants to publish a serverless application to the Serverless Application Repository, share an application privately or publicly, deploy an application from SAR via CloudFormation, version an application update using semantic versioning, compose nested SAR applications, configure an application policy for cross-account deployment, or understand the SAM transform pipeline. Do NOT invoke for AWS Service Catalog product registration (different catalog), CDK app publishing (CDK has its own publishing path), or AppRegistry metadata grouping (AppRegistry is metadata-only, not a deploy surface).", "dependencies": "aws-orchestrator", "requires_llm": "true", "verdict_shape": "READY_TO_DEPLOY | PREREQUISITES_MISSING", "lifecycle_status": "active", "supports_pipeline": "true" }
- description
- Provisions AWS Serverless Application Repository (SAR) applications with production defaults: SAM template (template.yaml) with Transform: AWS::Serverless-2016-10-31, README.md (required for publish), LICENSE (required for public), application packaging (zip upload or S3 bucket with code URI), semantic versioning (SemVer — required for every publish), application sharing model (private vs account-grant vs public), application policy (who can deploy cross-account), nested applications (AWS::Serverless:: Application), application parameters (cloudformation parameters surfaced at deploy time), deployment role (CAPABILITY_IAM / CAPABILITY_NAMED_IAM / CAPABILITY_AUTO_EXPAND), SAM transform during deploy (transform happens BEFORE CloudFormation sees the template), published author profile (author name, URL. Triggers: publish serverless application, sar publish, serverless application repository, sam package, sam deploy, sar application policy, cross-account sar deploy, nested sar application, semantic version sar.
- compatibility
- Agent runtime that reads SKILL.md (Claude Code, Cursor, Windsurf, Codex, Gemini). For live deployment: AWS SAM CLI (sam package, sam deploy) or AWS CLI v2 with serverlessrepo create-application / put-application-policy / create-cloud-formation-change-set. Requires an S3 bucket for artifact storage and IAM permissions for cloudformation:CreateChangeSet, serverlessrepo:CreateApplication, and the transforms the SAM template declares.
02 资源文件 19
- 参考文档eval/test-cases.yaml6.1 KB
- 参考文档evals/baselines/missing-readme-license.md626 B
- 参考文档evals/baselines/nested-applications-composition.md946 B
- 参考文档evals/baselines/private-app-sam-deploy.md757 B
- 参考文档evals/baselines/public-app-cross-account-policy.md730 B
- 参考文档evals/baselines/semantic-version-update.md680 B
- 参考文档evals/eval_config.yaml1.8 KB
- 参考文档evals/evals.json10.5 KB
- 参考文档evals/prompts/missing-readme-license.md377 B
- 参考文档evals/prompts/nested-applications-composition.md647 B
- 参考文档evals/prompts/private-app-sam-deploy.md733 B
- 参考文档evals/prompts/public-app-cross-account-policy.md618 B
- 参考文档evals/prompts/semantic-version-update.md496 B
- 参考文档examples/README.md6.4 KB
- 参考文档references/advanced-patterns.md5.7 KB
- 参考文档references/error-handling.md1.5 KB
- 参考文档references/sam-transform-and-deploy.md14.5 KB
- 参考文档references/sar-publishing-and-sharing.md13.2 KB
- 参考文档skill.usf.yaml4.5 KB
03 SKILL.md 正文
Serverless Application Repository Deployer
An AWS CloudOps agent skill that provisions AWS Serverless Application Repository (SAR) applications with correct defaults. The skill walks the operator through the SAM template structure, packaging (zip upload or S3), semantic versioning, the application sharing model (private vs account-grant vs public), the application policy that gates cross- account deploy, the SAM transform pipeline (transform happens BEFORE CloudFormation), nested application composition, the deployment role and capabilities, and application deletion/cleanup. It captures the application definition decisions, explains why each default matters, and emits a READY_TO_DEPLOY checklist with copy-pasteable verification commands.
Activation keywords
publish serverless application, sar publish, serverless application repository, sam package, sam deploy, sar application policy, cross- account sar deploy, nested sar application, semantic version sar.
STRICT output contract
When this skill is invoked with a SAR-provisioning request (publish
an application, share an application, deploy someone else's
application, version an update, compose nested applications, or a
partial configuration), the agent MUST respond with the
READY_TO_DEPLOY checklist defined in the "Output format" section
using the literal all-caps labels SAR_APPLICATION:, VERDICT:,
CHECKLIST:, and VERIFICATION_COMMANDS:. Do NOT preface the
checklist with prose, headings, or disclaimers — emit the block as
the first lines of the response. This contract is what assertion-
based evals and downstream provisioning pipelines rely on; deviating
from the literal labels breaks automation silently.
If any prerequisite is missing, the verdict is PREREQUISITES_MISSING
with a specific gap citation in the checklist (marked [✗]), and
READY_TO_DEPLOY MUST NOT also appear.
Quick navigation
| Section | When to read |
|---|---|
| Prerequisites | Always — verify before provisioning |
| Step 1 — Application structure (template.yaml + README + LICENSE) | Core app anatomy |
| Step 2 — SAM transform pipeline | Transform happens before CFN |
| Step 3 — Packaging (zip upload or S3 code URI) | Artifact storage |
| Step 4 — Semantic versioning | Every publish needs a version |
| Step 5 — Application sharing (private vs public) | Visibility model |
| Step 6 — Application policy (cross-account deploy) | Who can deploy |
| Step 7 — Deployment via CloudFormation change set | Deploy mechanism |
| Step 8 — Deployment role and capabilities | IAM surface |
| Step 9 — Nested applications | Composition |
| Step 10 — Application parameters | Surfaced at deploy time |
| Step 11 — Author profile and labels | Published metadata |
| Step 12 — Deletion and cleanup | Teardown |
| Step 13 — SAR vs AppRegistry | Avoid confusion |
| Step 14 — Recent features | Latest |
| NEVER do these things | Review before signing off |
| Output format | The literal checklist template |
| references/sam-transform-and-deploy.md | Transform + deploy detail |
| references/sar-publishing-and-sharing.md | Publishing + sharing detail |
Mindset
Moved to references/advanced-patterns.md. Three provisioning-time misconceptions: publish vs deploy, cross-account 403 without an application policy, mandatory immutable SemVer.
Configuration dependency graph (novel heuristic)
SAR application configurations are NOT independent. The SAM template must exist before packaging. Packaging must complete before publish. Publish must complete before sharing. The application policy must exist before cross-account deploy. Use this graph to sequence provisioning.
| Configuration | Hard dependencies (API error without) | Silent failure / immutability | Enables downstream |
|---|---|---|---|
| SAM template (template.yaml) | Valid YAML; Transform declared; resources under 200 | Template with unresolved CodeUri uploads raw path, not code |
the application definition |
| README.md | Required at publish time (CreateApplication / UpdateApplication) | Empty README is accepted but app cannot be shared publicly without content | public sharing eligibility |
| LICENSE | Required for PUBLIC sharing only; private apps can omit | App without LICENSE cannot be made public (API rejects) | public sharing |
| Packaging (sam package) | S3 bucket exists; IAM s3:PutObject | Forgetting to package → CodeUri points to local path → deploy fails | S3-backed code artifact |
| Semantic version | Required at every publish; must be unique per application | Reusing a version → API rejects with ConflictException; no overwrite | update management |
| Publish (create-application) | Template packaged; README present; version set | Publishing without an application policy → only the publisher account can deploy | catalog entry |
| Application policy | Application published; consumer AWS account ID(s) known | Policy omitted → cross-account deploy fails with 403 | cross-account deployment |
| Deployment (create-cloud-formation-change-set) | Application published; consumer has permission; capabilities match | Missing CAPABILITY_AUTO_EXPAND → nested application deploy fails | running stack |
| Nested application | Parent template uses AWS::Serverless::Application; child app published and accessible | Child app not shared → parent deploy fails at expand time | composition |
The application-policy-gates-cross-account row is the one a baseline model misses. Publishing the app is necessary but NOT sufficient for cross-account use. The policy must explicitly grant each consumer account (for private) or be set to public (for public apps). The SAM-transform-before-CFN row is the second commonly misunderstood step.
Cross-dependency gotchas:
Moved to references/advanced-patterns.md. Five gotchas: deploy-time transform, CAPABILITY_AUTO_EXPAND for nested apps, private sharing tiers, stack vs SAR deletion, version embedded in the ARN.
Expert heuristic: the SAM transform pipeline
A baseline model says "upload the template and deploy." The correct heuristic recognizes that SAR stores the RAW SAM template and the transform happens at DEPLOY time on the CONSUMER side.
Publisher flow:
1. Write template.yaml (Transform: AWS::Serverless-2016-10-31)
2. sam package → uploads code to S3, produces packaged.yaml
3. serverlessrepo create-application → stores SAM template + metadata
4. (optional) serverlessrepo put-application-policy → grants consumers
Consumer flow:
1. serverlessrepo create-cloud-formation-change-set → SAR fetches template
2. SAM transform runs → AWS::Serverless::Function → AWS::Lambda::Function
3. CloudFormation receives the EXPANDED template
4. CloudFormation creates/updates the stack with CAPABILITY_IAM
Key implication: the publisher's SAM template must be self- contained and valid for transformation. Any intrinsic function refs must resolve within the consumer's account at deploy time. The publisher cannot pre-transform — the transform is inherently a deploy- time operation because it may generate account-specific resources (IAM roles, API Gateway stage names, etc.).
Expert heuristic: application policy gates cross-account deploy
A baseline model publishes the app and assumes it is deployable everywhere. The correct heuristic recognizes three sharing tiers, each with a different deploy permission model.
Sharing tier decision:
├── PRIVATE (default)
│ → Only the publisher account can deploy
│ → No application policy needed
│ → ARN: arn:aws:serverlessrepo:<region>:<acct>:apps/<app>
│
├── PRIVATE + APPLICATION POLICY (account-grant)
│ → Publisher grants specific AWS account IDs
│ → put-application-policy with Principal: {AWS: ["arn:...:<acct>"]}
│ → Each granted account can deploy via create-cloud-formation-change-set
│ → Top-level deployment status: "AWS::ServerlessRepo::Application"
│
└── PUBLIC
→ Anyone can discover and deploy (with capabilities)
→ Requires LICENSE file in the application
→ No application policy needed (public = open)
→ Public apps appear in the SAR catalog search
Key implication: the application policy is the access control mechanism for PRIVATE cross-account sharing. For PUBLIC apps, the policy is implicit (anyone). Missing the policy for a private cross- account deploy is the #1 cause of "403 Forbidden" at deploy time.
Expert heuristic: semantic versioning for update management
A baseline model treats versioning as a label. The correct heuristic recognizes that SAR uses semantic versioning as an immutable, monotonic identity for each published version.
Semantic version rules (SAR enforces strict SemVer):
Format: MAJOR.MINOR.PATCH[-prerelease]
├── MAJOR — breaking changes (new required parameters, removed resources)
├── MINOR — backward-compatible features (new optional parameters, new resources)
├── PATCH — backward-compatible fixes (bug fixes, template corrections)
└── -prerelease — alpha/beta/rc (e.g., 1.0.0-beta, 2.0.0-rc.1)
Immutability:
├── Each version is published ONCE — cannot overwrite
├── Re-publishing the same version → ConflictException
└── To update, publish a NEW version (e.g., 1.0.0 → 1.0.1)
Consumer update:
├── Consumer pins: SemVerVersion: "1.0.0"
├── To update: change to "1.0.1" and re-run create-cloud-formation-change-set
└── SAR keeps ALL versions — consumers can rollback by pinning older
Key implication: versioning is the ONLY update mechanism. There is no "latest" pointer — consumers must reference a specific version. Plan version increments as part of the release pipeline.
Prerequisites (verify before provisioning)
Before emitting provisioning commands, verify these prerequisites. If any are missing, the verdict is PREREQUISITES_MISSING.
| Prerequisite | Why it matters | How to verify |
|---|---|---|
| SAM template (template.yaml) exists and is valid | The template defines the application resources | sam validate --template template.yaml |
| Transform declared in template | Required for SAM resources to expand | Confirm Transform: AWS::Serverless-2016-10-31 |
| README.md exists | Required for publish (any visibility) | Check file exists and has content |
| LICENSE exists (for public sharing) | Required for public apps; private can omit | Check file exists if sharing=public |
| S3 bucket for packaging | sam package uploads code artifacts to S3 | aws s3 ls s3://<bucket> |
| Semantic version defined | Every publish requires a unique version | Confirm version string follows SemVer |
| AWS account ID (publisher) | The publishing account owns the application | aws sts get-caller-identity |
| Consumer account IDs (for private sharing) | Application policy grants specific accounts | Confirm account IDs |
| IAM: serverlessrepo:CreateApplication | Required to publish | Check policy includes serverlessrepo actions |
| IAM: cloudformation:CreateChangeSet | Required to deploy | Check CloudFormation permissions |
| Sharing decision (private vs public) | Determines policy requirements | Confirm visibility scope |
If any prerequisite is missing, output VERDICT: PREREQUISITES_MISSING
and cite the specific gap.
Step 1 — Application structure (template.yaml + README + LICENSE)
A SAR application consists of three required components (LICENSE is required only for public sharing):
| Component | Required for | Purpose |
|---|---|---|
| template.yaml (SAM) | All publishes | Defines the serverless resources |
| README.md | All publishes | Human-readable documentation; required by SAR API |
| LICENSE | Public sharing only | Open-source license; private apps can omit |
| (optional) metadata.yaml | Not required | Extra metadata; SAR API has dedicated fields |
Moved to references/sam-transform-and-deploy.md. Minimal template.yaml (Transform, Parameters, S3-event Lambda, Outputs) and required README.md content.
Step 2 — SAM transform pipeline
The SAM transform (AWS::Serverless-2016-10-31) is a macro that
expands AWS::Serverless::* resource types into CloudFormation-
native resources. This expansion happens at DEPLOY time (when the
consumer deploys the app), not at publish time.
Moved to references/sam-transform-and-deploy.md. SAM type expansion table, auto-generated IAM roles note, transform dry run via sam build/package.
Step 3 — Packaging (zip upload or S3 code URI)
Before publishing, the application's code must be packaged into an
S3-backed artifact. The sam package command handles this.
Moved to references/sam-transform-and-deploy.md. sam package CLI, CodeUri rewrite to S3, published-template rule, S3 bucket requirements.
Step 4 — Semantic versioning
Every publish operation requires a semantic version. The version
follows SemVer format: MAJOR.MINOR.PATCH[-prerelease].
Moved to references/sar-publishing-and-sharing.md. MAJOR/MINOR/PATCH/prerelease bump table, create-application publish and version-update CLI, unique-version rule.
Step 5 — Application sharing (private vs public)
SAR applications have three sharing tiers:
| Tier | Visibility | Deploy permission | LICENSE required |
|---|---|---|---|
| PRIVATE (default) | Only publisher account | Publisher only | No |
| PRIVATE + policy | Discoverable by granted accounts | Granted accounts only | No |
| PUBLIC | Everyone (catalog search) | Anyone with capabilities | YES |
Moved to references/sar-publishing-and-sharing.md. get-application sharing-status check and IsVerifiedAuthor public-app verification.
Step 6 — Application policy (cross-account deploy)
For PRIVATE cross-account sharing, the publisher must grant each consumer account via an application policy.
Moved to references/sar-publishing-and-sharing.md. put-application-policy / get-application-policy CLI; CreateCloudFormationChangeSet action gates consumer deploy.
Step 7 — Deployment via CloudFormation change set
Consumers deploy a SAR application by creating a CloudFormation change set from the application. This triggers the SAM transform and creates the stack.
Moved to references/sam-transform-and-deploy.md. Consumer deploy CLI: create-cloud-formation-change-set, execute-change-set, sam deploy.
Step 8 — Deployment role and capabilities
The consumer's deployment role must have permissions for all resources the SAM template creates. The capabilities declare what the stack is allowed to do.
| Capability | When required |
|---|---|
| CAPABILITY_IAM | Template creates IAM roles/policies (SAM auto-generates these) |
| CAPABILITY_NAMED_IAM | Template creates IAM resources with custom names |
| CAPABILITY_AUTO_EXPAND | Template contains nested applications (AWS::Serverless::Application) |
| CAPABILITY_RESOURCE_POLICY | Template modifies resource policies (e.g., S3 bucket policy) |
Critical: most SAM templates need at least CAPABILITY_IAM because
the transform auto-generates IAM roles for functions with Policies.
Nested applications additionally require CAPABILITY_AUTO_EXPAND.
Step 9 — Nested applications
A SAR application can include other SAR applications using the
AWS::Serverless::Application resource type. This enables composition.
Moved to references/sam-transform-and-deploy.md. Parent template with AWS::Serverless::Application (Location/Parameters/NotificationARNs/TimeoutInMinutes).
Requirements for nested applications:
- The nested app must be published and accessible (shared or public).
- The consumer must have deploy permission for the nested app.
- CAPABILITY_AUTO_EXPAND is REQUIRED at deploy time.
- The nested app deploys as a nested CloudFormation stack.
Step 10 — Application parameters
Parameters defined in the SAM template are surfaced to the consumer
at deploy time. The consumer provides values via --parameter-overrides.
Moved to references/sam-transform-and-deploy.md. Parameters YAML (BucketName, MemorySize, EnableXRay) and --parameter-overrides deploy example.
Step 11 — Author profile and labels
Moved to references/sar-publishing-and-sharing.md. Author profile field table: author, home-page-url, source-code-url, labels (max 10), SpdxLicenseId, IsVerifiedAuthor.
Step 12 — Deletion and cleanup
Deleting a SAR application is a two-step process: delete the deployed stack, then delete the application from the catalog.
Moved to references/advanced-patterns.md. Two-step teardown: delete-stack then delete-application; neither cascades to the other.
Step 13 — SAR vs AppRegistry
SAR and AppRegistry serve different purposes:
Moved to references/advanced-patterns.md. SAR vs AppRegistry comparison: deploy surface vs metadata grouping, versioning, sharing.
Step 14 — Recent features
Moved to references/advanced-patterns.md. 2023-2026: sam build esbuild, public-app verification streamlining, nested version ranges, transform performance, cross-region deploy, CDK SAR construct.
NEVER do these things
-
NEVER publish a SAR application without a README.md. The SAR API requires README content at publish time. Without it, the CreateApplication call fails.
-
NEVER publish as PUBLIC without a LICENSE file. Public apps require a license. The API rejects public publishes without one. Private apps can omit the license.
-
NEVER reuse a semantic version. Each publish must use a unique version. Reusing a version results in a ConflictException. Plan version increments as part of the release pipeline.
-
NEVER forget the SAM transform declaration. The template must include
Transform: AWS::Serverless-2016-10-31. Without it,AWS::Serverless::*types are not recognized and the deploy fails. -
NEVER deploy a nested application without CAPABILITY_AUTO_EXPAND. Templates with
AWS::Serverless::Applicationrequire this capability. CloudFormation rejects the change set without it. -
NEVER assume publishing makes an app deployable cross-account. For private apps, you MUST add an application policy granting each consumer account. Without the policy, consumers get a 403.
-
NEVER forget that the SAM transform auto-generates IAM roles. Even if the template does not explicitly declare AWS::IAM::Role, the transform creates roles for functions with
Policies. CAPABILITY_IAM is required. -
NEVER confuse SAR with AppRegistry. SAR deploys serverless applications from SAM templates. AppRegistry groups existing resources for metadata. They are different services.
-
NEVER assume deleting the CloudFormation stack deletes the SAR app. The stack and the SAR catalog entry are separate. Delete both explicitly. Conversely, deleting the SAR app does not delete already-deployed stacks.
-
NEVER upload the raw template.yaml (with local CodeUri) to SAR. Always run
sam packagefirst to replace local CodeUri with S3 URIs. Publishing the raw template means consumers cannot access the code.
Output format
SAR_APPLICATION: <application-name> (<semantic-version>)
VERDICT: READY_TO_DEPLOY | PREREQUISITES_MISSING
CHECKLIST:
[✓|✗] SAM template: <template-file> (Transform: AWS::Serverless-2016-10-31)
[✓|✗] README.md: present | MISSING (required for publish)
[✓|✗] LICENSE: present | not required (private) | MISSING (required for public)
[✓|✗] Packaging: sam package → S3 artifact <s3-uri>
[✓|✗] Semantic version: <version> (SemVer format)
[✓|✗] Sharing: Private | Private+Policy (<account-ids>) | Public
[✓|✗] Application policy: granted (<account-ids>) | not needed (private) | public (implicit)
[✓|✗] Capabilities: CAPABILITY_IAM [CAPABILITY_NAMED_IAM] [CAPABILITY_AUTO_EXPAND]
[✓|✗] Parameters: <param-list> surfaced at deploy time
[✓|✗] Nested applications: none | <child-app-ids>
[✓|✗] Author profile: <author>, labels: <label-list>
[✓|✗] Application ARN: arn:aws:serverlessrepo:<region>:<acct>:apps/<name>
VERIFICATION_COMMANDS:
aws serverlessrepo get-application --application-id <arn> --region <region>
aws cloudformation describe-stacks --stack-name <stack-name> --region <region>
Worked example — private app with SAM deploy and cross-account policy
SAR_APPLICATION: s3-file-processor (1.0.0)
VERDICT: READY_TO_DEPLOY
CHECKLIST:
[✓] SAM template: template.yaml (Transform: AWS::Serverless-2016-10-31)
[✓] README.md: present (S3 File Processor documentation)
[✓] LICENSE: present (Apache-2.0)
[✓] Packaging: sam package → s3://my-artifacts/s3-processor-1.0.0.zip
[✓] Semantic version: 1.0.0
[✓] Sharing: Private+Policy (granted to 999999999999)
[✓] Application policy: PutApplicationPolicy → Principal: 999999999999, Action: CreateCloudFormationChangeSet
[✓] Capabilities: CAPABILITY_IAM (transform auto-generates Lambda execution role)
[✓] Parameters: BucketName (String, required), MemorySize (Number, default 256)
[✓] Nested applications: none
[✓] Author profile: Jacky Chan, labels: s3, lambda, event-driven
[✓] Application ARN: arn:aws:serverlessrepo:us-east-1:123456789012:apps/s3-file-processor
VERIFICATION_COMMANDS:
aws serverlessrepo get-application --application-id arn:aws:serverlessrepo:us-east-1:123456789012:apps/s3-file-processor --region us-east-1
aws serverlessrepo get-application-policy --application-id arn:aws:serverlessrepo:us-east-1:123456789012:apps/s3-file-processor --region us-east-1
Error handling
Moved to references/error-handling.md. Six failure modes: README required, ConflictException, 403 policy gap, missing CAPABILITY_AUTO_EXPAND, transform failed, artifact upload.
References (load on demand)
- advanced-patterns — Mindset misconceptions, cross-dependency gotchas, deletion/cleanup, SAR vs AppRegistry, recent AWS features
- error-handling — Six API failure modes: missing README, ConflictException, 403 policy gap, AUTO_EXPAND, transform failure, artifact upload
- sam-transform-and-deploy — Transform/deploy deep reference plus moved Step 1/2/3/7/9/10 template, packaging, and deploy CLI
- sar-publishing-and-sharing — Publishing/sharing deep reference plus moved Step 4/5/6/11 versioning, sharing, policy, and author-profile CLI
Domain
AWS CloudOps / AWS Serverless Application Repository Application Publishing & Deployment.
AWS documentation
- Serverless Application Repository — https://docs.aws.amazon.com/serverlessrepo/latest/devguide/what-is-serverlessrepo.html
- Publishing applications — https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverlessrepo-publishing-applications.html
- Sharing applications — https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverlessrepo-sharing-applications.html
- Deploying applications — https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverlessrepo-consuming-applications.html
- SAM transform — https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/transform.html
- AWS::Serverless::Application — https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-application.html
- Application policies — https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverlessrepo-how-to-use.html
- SAM CLI reference — https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-reference.html
- Semantic versioning — https://semver.org/
04 同仓库更多 Skills
xray-tracing-deployer
Deploys AWS X-Ray distributed tracing with production-grade configuration: X-Ray daemon deployment (EC2 systemd, ECS sidecar, EKS DaemonSet, Lambda built-in), SDK instrumentation (Java, Python, Node.js, Go, .NET) with annotations and metadata, sampling rules (default reservoir + rate vs custom rules with URL / method / service-name predicates), service map generation, trace query and retrieval, groups and insights, CloudWatch ServiceLens integration, IAM permissions (PutTraceSegments, GetSamplingRules), and latest features (Lambda Powertools tracing, OpenTelemetry / ADOT Collector support, W3C trace context). Emits a READY_TO_DEPLOY checklist with every configuration item verified. Use when enabling X-Ray on a new application, adding tracing to ECS / EKS / Lambda, validating a sampling configuration, or generating daemon deployment CLI and IaC templates. Triggers: X-Ray, distributed tracing, X-Ray daemon, sampling rules, service map, X-Ray SDK, OpenTelemetry, ADOT, Lambda Powertools, CloudWatch ServiceLens.
wellarchitected-workload-auditor
Audits AWS Well-Architected Tool workloads for review staleness, per-pillar high-risk issue counts, milestone tracking gaps, and remediation plan completeness. Emits a deterministic verdict (STALE_REVIEW | HIGH_RISK | CONFIG_GAP | OK) per workload with per-pillar risk breakdown, milestone trend analysis, and specific remediation. Use when reviewing Well-Architected workloads, checking WA review freshness, auditing high-risk issues per pillar, validating milestone coverage, or tracking remediation plans.
wellarchitected-review-operator
Operates AWS Well-Architected Tool reviews end-to-end — creates workloads, runs pillar reviews (operational excellence, security, reliability, performance, cost optimization, sustainability, Prosperity), answers questions with risk-tier rationale, generates reports and improvement plans, creates milestones, and integrates with Trusted Advisor and Well-Architected Labs. Runs deterministic pre-checks (workload existence, lens availability, pillar coverage), emits the exact update-answer / get-consolidated-report CLI behind a CONFIRM gate, and verifies risk-tier transitions. Emits READY | BLOCKED | COMPLETED. Use when creating a workload, answering pillar questions, generating an improvement plan, creating a milestone, or integrating with Trusted Advisor. Triggers: well-architected tool, well architected review, workload review, pillar, operational excellence, security, reliability, performance, cost optimization, sustainability, prosperity, improvement plan, milestone, trusted advisor.
wafv2-web-acl-deployer
Provisions AWS WAFv2 Web ACLs with correct production defaults: scope selection (CLOUDFRONT vs REGIONAL), managed rule groups (AWSManagedRulesCommonRuleSet, SQLiRuleSet, LinuxRuleSet, WindowsRuleSet, IPReputationList, BotControlRuleSet, AmazonIpReputationList, ATP), custom rules (byte match, IP set, regex pattern, geo match, size constraint, rate-based), rule priority ordering, logging destinations (Kinesis Firehose, CloudWatch Logs, S3), resource association (ALB, API Gateway, CloudFront), rate-based rules with aggregate keys (IP, forwarded IP), Challenge and CAPTCHA actions, and account takeover prevention. Emits a READY_TO_DEPLOY checklist. Use when creating a Web ACL, attaching managed rules, configuring rate limiting, enabling WAF logging, associating a Web ACL with an ALB/API Gateway/CloudFront, or configuring CAPTCHA/Challenge actions. Triggers: create WAF Web ACL, WAFv2, managed rule groups, WAF rate limiting, WAF logging, WAF CAPTCHA, WAF Challenge action, bot control, ATP managed rules.
wafv2-web-acl-auditor
Audits AWS WAFv2 Web ACL configurations to determine whether the ACL provides effective protection: default-action posture (Allow vs Block), managed-rule-group coverage gaps, rule effectiveness (BLOCK vs COUNT, shadow/bypass rules, stale exclusions), rate-based rule correctness, logging and visibility configuration, and text-transformation bypass vectors. Emits a deterministic verdict per Web ACL. Use when reviewing a WAFv2 Web ACL for security posture, checking managed-rule coverage, validating rate-limit configuration, auditing WAF logging, or hardening a WAF before production deployment. Triggers: WAF, WAFv2, Web ACL, managed rule group, AWSManagedRules, rate-based rule, CAPTCHA, Challenge, OverrideAction, Count mode, forwarded IP, Bot Control, ATP, text transformation, WAF logging, WAF visibility, OWASP, SQLi, XSS, RFI.
waf-rule-deployer
Provisions AWS WAFv2 rule sets with production defaults: Web ACL creation (CloudFront scope in us-east-1 vs Regional scope), rule groups (managed vs custom) with capacity planning in WCU (Web ACL Capacity Units, 1500 default per ACL), managed rule groups (AWSManagedRulesCommonRuleSet, AWSManagedRulesSQLiRuleSet, AWSManagedRulesAmazonIpReputationList, AWSManagedRulesLinuxRuleSet, AWSManagedRulesWindowsRuleSet, AWSManagedRulesUnixRuleSet), custom rules (byte-match, regex pattern set, geo-match, rate-based), IP set and regex pattern set resources, rule priority ordering (lowest number evaluated first), action types (allow, block, count, CAPTCHA, Challenge), bot control managed rule group, account takeover. Triggers: create WAF rule, WAF managed rule group, WAF custom rule, WAF byte match, WAF geo match, WAF rate based rule, WAF IP set, WAF regex pattern set, WAF WCU budget, WAF CloudFront ACL, WAF logging Kinesis Firehose, WAF bot control, WAF ATP, WAF label matching, WAF Challenge action, WAF CAPTCHA.