Ship .NET to AWS. From scratch in 10 minutes.

A command-line companion for .NET teams shipping to AWS — from the first scaffold to every release after. One manifest powers the entire delivery pipeline: static-site previews for every PR, promotion through dev, stage, and prod, and five-second rollbacks. All with the reproducibility and audit trail hand-rolled CI scripts never gave you.

11K+ NuGet downloads
93 Releases
Free Community tier
~/Kanject.Analytics — zsh

Start fast.

Install the tool, check the machine, scaffold, deploy.

Free · .NET global tool
$ dotnet tool install -g Kanject.Cli
NuGet 11K+ downloads93 releases

Installs to your .NET global-tools folder — that folder must be on your PATH. If a fresh terminal still says command not found: kanject, it's PATH, not the install: set it up once →.

  1. Install

    dotnet tool install -g Kanject.Cli

    .NET global tool, straight from NuGet.org.

  2. Check

    kanject doctor

    Verifies .NET, AWS CLI, Lambda tools, PATH, and project shape.

  3. Scaffold

    kanject new webapi --name Kanject.Analytics

    Creates the solution, manifest, lockfile, stages, tests, and Lambda defaults.

  4. Deploy

    kanject aws deploy --env dev

    Packages, deploys, flips the alias, writes the ledger, then prints the URL.

One manifest, many targets.

Your .NET service is described once, in the manifest. Today it ships to AWS Lambda or ECS Fargate from that one contract, with the single-page app that fronts it as a static site — and more compute targets plug in without changing how you deploy.

you write
your .NET service csproj + handlers
one contract
manifest.json one contract · in git
devstageprod
where it runs
AWS Lambda shipped
zip / image → API Gateway
ECS Fargate shipped
container → load balancer
Static site shipped
SPA → S3 + CloudFront, coupled to its API
More targets coming
the same manifest, new compute
fans out across stagesregions Every deploy is recorded in the S3 ledger — audit and rollback read one source of truth.

Pick your path.

Different teams arrive with different problems. The CLI meets them where they are.

Green field

New .NET service

Go from an empty folder to a deployed dev API with stages, tests, manifest, and rollback already wired.

kanject new webapi
Existing app

Bring a Lambda under control

Add kanject beside an existing project without rewriting your app or replacing the AWS Lambda toolchain.

kanject init
Debugging

Reproduce cloud-only bugs locally

Run the app or Lambda TestTool with stage-shaped env, including clear warnings when secrets enter the local process.

kanject test --pull-env
Delivery

Ship every PR safely

Give each pull request a preview — a static site, or a single-entry zip Lambda service in a stack of its own — then deploy the same manifest to dev, stage, or prod.

kanject aws preview publish
Operations

Audit and recover

Browse the deployment ledger, mark bad versions, and flip prod back to a known-good Lambda version without rebuilding.

kanject aws rollback
Platform

Add CI, VPC, and domains

Scaffold CodePipeline/CodeBuild when you want AWS-native CI, or keep GitHub Actions and run deploy non-interactively.

kanject aws configure

Know what changes.

Five artifacts make the workflow predictable: reviewed inputs in git, one generated file, and an audit ledger in S3.

workflow artifacts
you edit · in git
manifest.json service identity Service name, provider, stages, entries, package type, cross-repo dependencies, and the optional preview policy.
manifest.lock.json sync output Pinned SHAs and content hashes so CI builds the same dependency graph every time.
stages/<stage>.json stage config Region, profile, stack, bucket, parameter path, and env references for each target.
kanject
aws deploy
kanject writes
aws-lambda-tools.<stage>.json deploy input · regenerated each deploy Regenerated from stage config before deploy. It is an output, not a file to hand-edit.
S3 deployment ledger audit + rollback Append-only version snapshots with commit SHA, deployer, env hashes, status, and alias target.
you edit (git) generated, ephemeral recorded in S3

CI that survives a cross-repo dependency.

If your service pulls shared libraries from other repos, a clean CI checkout can't find them — ..\..\Shared\Foo.csproj resolves on your machine and nowhere else, and the build goes red. kanject sync resolves each one from git at a pinned commit, so any runner builds the same graph.

without kanject
ci · fresh runner
$ git clone … && dotnet restore
Determining projects to restore…
✗ error NU1105: unable to find project information
for '..\..\Shared\Acme.Shared.csproj'.
✗ Build FAILED.
with kanject
ci · with kanject
$ kanject sync && dotnet build
✓ Acme.Shared cloned @ a1b2c3d · cached
✓ generated MSBuild imports · lock pinned
✓ Build succeeded.

On a fresh runner kanject sync runs first — cloning each cross-repo dependency at the commit pinned in manifest.lock.json and emitting deterministic MSBuild imports without editing consumer projects — so every runner builds the same graph.

Roll back.

Five seconds. No rebuild.

kanject-analytics — zsh

Command map.

Pick what you ship. The map narrows to your path.

Show the commands for

Each row is one command family; the pills are its verbs.

Scaffold or adopt, run it locally, deploy a stage, and roll back without a rebuild.

Set the policy once, declare a minor or major with the change, and release with one command.

Register the app, map where it downloads from, then build and publish every edition.

01
Set up

Start or adopt a project, then check the machine.

  • kanject new

    Create a project from a template.

  • kanject init

    Set up Kanject in an existing project.

  • kanject packages init

    Set up release policy in a library repository.

  • kanject doctor

    Check tools and project configuration.

  • kanject login
    • status

    Sign this machine in for paid Kanject libraries.

  • kanject update

    Update the CLI and bundled templates.

02
Daily

Shape the project, run it locally, keep builds reproducible.

  • kanject add
    • function
    • stage
    • env
    • secret
    • param
    • lib
    • package
    • distributable

    Add packages, functions, stages, or configuration.

  • kanject test

    Run the project locally.

  • kanject env

    Inspect a stage’s environment values, masked.

  • kanject sync

    Fetch cross-repo dependencies for the build.

  • kanject packages intent add

    Declare a minor or major with the change. A fix declares nothing.

  • kanject configure distribution

    Map an app to where it downloads from.

  • kanject migrate

    Upgrade project references or the manifest format.

03
Ship

Deploy, release, distribute, and recover.

  • kanject aws deploy

    Ship a stage to Lambda, ECS Fargate, or a static site.

  • kanject aws preview
    • publish
    • ls
    • url
    • extend
    • rm

    Short-lived previews for review; extend or remove them.

  • kanject aws rollback

    Put a prior release back live. No rebuild.

  • kanject aws deployments
    • list
    • show
    • mark
    • gc

    Read the ledger; mark releases stable or broken.

  • kanject aws configure
    • http
    • package
    • vpc
    • domain

    Set up HTTP access, zip or image packaging, VPC, and custom domains.

  • kanject aws pipeline
    • up
    • promote
    • status

    Provision CodePipeline and CodeBuild; promote rehearsed commits.

  • kanject packages release
    • status

    Release a library, from declared intent to approval.

  • kanject aws distribute
    • init
    • promote

    Build every edition, then publish to S3, CodeArtifact, or GitHub Releases.

  • kanject distribution release

    Write the release commit that raises a desktop app’s version.

What’s in the box.

The sharp edges kanject smooths over without replacing the tools you already trust.

Proof: kanject sync

Cross-repo dependencies

Declare a class library by git URL, ref, and project path. Kanject pins and caches the source, then emits deterministic MSBuild imports without editing consumer projects.

Proof: _ledger/versions/*.json

Deployment ledger

Every deploy writes an append-only snapshot with version ARN, commit SHA, lockfile hash, deployer, and env hashes. Audit and rollback read the same source of truth.

Proof: kanject aws preview url

Pull-request previews

Deploy a single-entry zip Lambda service as a short-lived stack of its own with kanject aws deploy --preview, or publish your site beneath an existing CloudFront distribution. One set of commands resolves the URL, extends the expiry, or removes either kind.

Proof: kanject add function

Multi-Lambda single stack

Schema v2 lets one service host multiple Lambda entries in a single CloudFormation stack when they should deploy and roll back as one atomic unit.

Proof: aws.provider

Plugin-loaded providers

AWS is the product path today. The provider host keeps cloud-bound commands behind adapters, with owner checks and isolated plugin loading for future provider packages.

Proof: kanject aws deploy --non-interactive

CI scaffolding (or not)

Generate CodePipeline and CodeBuild when you want AWS-native CI, or keep any runner that has .NET, AWS credentials, and the CLI installed.

You own every resource.

Kanject CLI deploys into your own AWS account — real CloudFormation you never have to write. Inspect the stack, diff it, tear it down. You pay AWS directly; nothing runs on Kanject's infrastructure.

Every deploy Created and managed for you on the first deploy.

AWS Lambda · ECS Fargate · CloudFront

Runs your .NET service — a Lambda function (new version + alias flip each deploy), or an autoscaling ECS Fargate service behind an Application Load Balancer — and serves the single-page app that fronts it from S3 behind a CloudFront distribution.

CloudFormation

Your whole service is one stack — a Lambda + API Gateway, an ECS service with its load balancer, or an S3 bucket with its distribution, plus IAM roles and log groups. Generated for you, never hand-authored: inspect it, diff it, delete it.

Amazon S3 · ECR

S3 keeps the append-only deployment ledger — every version, who shipped it, the hashes rollback trusts. ECR holds your container image when you ship an image package or an ECS service.

Only when you opt in Nothing here exists until you ask for it.

CodePipeline + CodeBuild

AWS-native CI, scaffolded by kanject aws pipeline. Skip it and run deploys from GitHub Actions instead.

SSM + Secrets Manager

Where stage environment values resolve from when you bind them — Parameter Store or Secrets Manager.

VPC + custom domains

Wired through the kanject aws configure wizards when a stage needs them.

One CloudFormation stack per service. You own it, you can read every line, and the bill comes from AWS — not from us.

Ship the apps and libraries, too.

kanject aws deploy puts your service on AWS. kanject aws distribute ships everything else — class libraries and desktop apps — built per edition and runtime, signed, and published where each kind belongs. Libraries split across a public and private feed, and kanject packages verify proves no private code ever leaks into the public one.

$kanject aws distribute --env release
library Acme.Sdk
communitypro
nuget.org public · community surface
CodeArtifact private · paid providers
desktop app Acme.App
win-x64osx-arm64linux-x64
S3 versioned bucket · candidate → stable
GitHub Releases release assets · github plugin

kanject packages verify walks the dependency closure before anything public ships and fails the build if a private package would leak into a public one. kanject aws distribute then fans every distributable × edition × RID cell out to its feed — nuget.org, CodeArtifact, S3, or GitHub Releases — and records what shipped where in a distribution ledger. kanject github distribute scopes a run to releases only.

We build and ship DynoStudio — our own desktop app — with kanject aws distribute.

Make the code as clean as the deploy.

You've scaffolded and deployed with the free CLI — and inside those projects you can write whatever you like, straight against the AWS SDK. Kanject Core is the optional paid layer that does it for you: eighteen .NET libraries that trade SDK boilerplate for clean, typed, testable C#, all in your own AWS account. And nothing new to install: when you license Core or BaaS, your license unlocks the private feeds, and the CLI you already have builds and deploys against them.

NoSqlDatabaseSqlDatabaseCacheDbFileRepositoryQueueChannelsEventsChangeFeedCloudFunctionApiAdapterQrLogsRecurringParallelEtlTaskManagerPackagesFeatures
Ready to run?

Start with the CLI docs.

Install Kanject CLI, scaffold a .NET service, and deploy your first AWS stage from the quick-start guide.