Skip to content
Skills Library
DevOps & cloud · Automation

webda-deploy

/webda-deploy

Use when deploying a Webda app, adding a deployment environment or building a container image or Lambda package

Repository
webda.io ↗
Licence
LGPL
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
1
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

LGPL, otwarta.

What it does and when to use it

Use when deploying a Webda app, adding a deployment environment or building a container image or Lambda package

Original author description

Use when deploying a Webda app, adding a deployment environment or building a container image or Lambda package

How it works

  1. When to use
  2. Pattern
  3. Common mistakes
  4. Verify
  5. Reference
Original SKILL.md headings · 100 lines, 580 words
SKILL.md preview
---
name: webda-deploy
description: Use when deploying a Webda app, adding a deployment environment or building a container image or Lambda package
---

# Webda deploy

## When to use

Adding an environment (`deployments/<name>.json`), building and pushing an OCI image, packaging the app for AWS Lambda or deploying it with CloudFormation.

## Pattern

Install the deployer package, then build: a generated app does not depend on any deployer, and the deployer types and commands are only discovered from the installed packages.

```bash
npm install @webda/oci   # Webda/ContainerDeployer
npm install @webda/aws   # Webda/LambdaPackager, Webda/CloudFormationDeployer
npm run build            # also before every deployer command: lib/ and webda.module.json get packaged
```

A deployment is a file `deployments/<name>.json` (`.jsonc`, `.yaml` and `.yml` work too). It has four sections:

- `parameters` and `services` override `webda.config.json` (objects deep merged, arrays replaced; see webda-configuration).
- `units` lists the deployers: each unit has a `name`, a `type` and the deployer parameters.
- `resources` holds parameters shared by every unit; a unit overrides them.

```json
{
  "$schema": "../.webda/deployment.schema.json",
  "parameters": {
    "supportEmail": "support@example.com"
  },
  "services": {
    "ReminderService": { "delayHours": 48 }
  },
  "units": [
    {
      "name": "image",
      "type": "Webda/ContainerDeployer",
      "image": "ghcr.io/my-org/my-app",
      "tags": ["${package.version}", "latest"],
      "credentials": {
        "ghcr.io": { "username": "${env.GHCR_USER}", "password": "${env.GHCR_TOKEN}" }
      }
    }
  ]
}
```

Select the deployment with `-d <name>` placed before the command name (after it, `-d` is silently ignored), `--deployment <name>` anywhere, or the `WEBDA_DEPLOYMENT` environment variable. `webda` is not on the PATH of a generated app: use `npx webda` (or `npm exec -- webda`). The same selection applies to `serve` and `debug`: they run the app with the overrides of that deployment.

```bash
npx webda -d production container build   # OCI layout in .webda/oci/<unit>, base layers included
npx webda -d production container push    # build and push every tag of the unit
npx webda -d production aws package       # Lambda zip (LambdaPackager unit), dist/lambda-<version>.zip by default
npx webda -d production deploy            # run `deploy` of every unit that has it (ContainerDeployer, CloudFormationDeployer)
npx webda -d production --service image container push   # only the unit named image
WEBDA_DEPLOYMENT=production npm run serve         # npm scripts: environment variable
npm run serve -- --deployment production         # or --deployment, never -d after the command
```

Units of other types in the same deployment:

```json
{
  "units": [
    { "name": "package", "type": "Webda/LambdaPackager", "zipPath": "dist/app.zip" },
    {
      "name": "stack",
      "type": "Webda/CloudFormationDeployer",
      "AssetsBucket": "my-artifacts",
      "Lambda": {},
      "APIGateway": {}
    }
  ]
}
```

`Webda/LambdaPackager` is independent from `Webda/CloudFormationDeployer`: the latter packages its own Lambda from its `LambdaPackager` parameter.

Units are not services of the app: a unit is only instantiated by a command its type provides, `serve` and `debug` never create it. `${...}` templates in unit parameters (`${package.version}`, `${git.commit}`, `${deployment}`, `${env.NAME}`) are replaced when the command runs.

## Common mistakes

```text
Deployer config in "services"                → it goes in "units"; "services" only overrides app services
A unit named like an app service             → DEPLOYMENT_UNIT_CONFLICT, rename the unit
Running a deployer command without -d        → DEPLOYMENT_REQUIRED: select the deployment
-d after the command name                    → ignored silently; put it before, or use --deployment
Deployer package not installed               → unit of an unknown type is skipped silently, no command: npm install @webda/oci or @webda/aws, npm run build
Secrets in deployments/*.json                → "${env.NAME}" in a unit parameter; parameters/services values are not interpolated, service secrets come from the environment variables the service reads
```

## Verify

`npx webda -d production container build` logs `Built sha256:... in <path>` (it downloads the base image layers once, so it needs network access). `npx webda --help` lists the commands of the installed deployers (`@webda/oci`, `@webda/aws`).

## Reference

https://docs.webda.io

Written for Webda 4.0.0-beta.

Versions

The database has no other skills named webda-deploy.

Database snapshot: 13.11.2026 · package version a66b27cdbe3c (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100webda-testing
    Use when writing, running or fixing tests of a Webda app, its models, services or operations
  • 100webda-configuration
    Use when changing webda.config.json, application parameters, the parameters of a service or the per-environment deployments of a Webda app
  • 100aws-lambda-packaging-and-configuration
    Packages an AWS Lambda function as a zip deployment package or container image, tunes memory/timeout/ephemeral storage, mitigates cold starts, and scopes the function's IAM execution role to least privilege. Use when the user asks to "package a Lambda function," "build a…
  • 85aws-lambda
    Design, build, deploy, test, and debug serverless applications with AWS Lambda. Triggers on phrases like: Lambda function, event source, serverless application, API Gateway, EventBridge, Step Functions, serverless API, event-driven architecture, Lambda trigger. For deploying…
  • 90aws-lambda
    Design, build, deploy, test, and debug serverless applications with AWS Lambda. Triggers on phrases like: Lambda function, event source, serverless application, API Gateway, EventBridge, Step Functions, serverless API, event-driven architecture, Lambda trigger. For deploying…
  • 100aws-lambda
    Build and deploy serverless functions on AWS Lambda. Configure triggers, manage permissions, and optimize performance. Use when implementing serverless applications.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.