Installation

Tenantry.Pro's packages are published to a private GitHub Packages feed owned by the tenantry-org GitHub organisation. Tenantry core (Tenantry.Core, Tenantry.AspNetCore, Tenantry.EfCore) and everything else stay on nuget.org. This page sets up a machine and a CI pipeline to restore from both.

What you needCopy Anchor Link

1. A Tenantry Pro subscription, and your GitHub account connected on your Pro access page. Connecting it invites that account to the tenantry-org organisation; accept the invitation (GitHub emails it, and the Pro access page links to it). Membership of the organisation is what gives read access to the feed.
2. A GitHub personal access token (classic) created by that same account, with only the read:packages scope. GitHub Packages accepts classic tokens only: fine-grained tokens do not work with the NuGet registry. Create one and give it an expiry date.
3. Your licence key, from the same Pro access page. It does not expire; see Licensing.

1. Add a nuget.configCopy Anchor Link

Put this nuget.config next to your solution file and commit it. It holds no secrets: the credentials are read from two environment variables.

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <packageSources>
    <clear />
    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
    <add key="tenantry-pro" value="https://nuget.pkg.github.com/tenantry-org/index.json" />
  </packageSources>
  <packageSourceMapping>
    <packageSource key="nuget.org">
      <package pattern="*" />
    </packageSource>
    <packageSource key="tenantry-pro">
      <package pattern="Tenantry.Pro" />
      <package pattern="Tenantry.Pro.*" />
    </packageSource>
  </packageSourceMapping>
  <packageSourceCredentials>
    <tenantry-pro>
      <add key="Username" value="%TENANTRY_GITHUB_USERNAME%" />
      <add key="ClearTextPassword" value="%TENANTRY_GITHUB_PAT%" />
    </tenantry-pro>
  </packageSourceCredentials>
</configuration>

What each part does:

• <clear /> drops sources inherited from your user or machine configuration, so every machine and CI runner restores from exactly these two.
• packageSourceMapping sends Tenantry.Pro and Tenantry.Pro.* to the private feed and everything else to nuget.org. The most specific pattern wins, so Tenantry.Core and the rest of Tenantry core come from nuget.org, and your other dependencies are never requested from GitHub. It also means no other source can supply a package named Tenantry.Pro.
• packageSourceCredentials authenticates to the private feed. %NAME% is replaced with the environment variable's value (on Windows, macOS and Linux). The element name must match the source's key, tenantry-pro.

If your solution already has a nuget.config, merge these entries into it. With source mapping on, every source needs at least one pattern, so map any other feeds you use (a company feed, say) as well.

2. Set the credentials on your machineCopy Anchor Link

Set the two variables in your shell profile or user environment:

# macOS / Linux
export TENANTRY_GITHUB_USERNAME=your-github-username
export TENANTRY_GITHUB_PAT=ghp_your_token

# Windows
[Environment]::SetEnvironmentVariable('TENANTRY_GITHUB_USERNAME', 'your-github-username', 'User')
[Environment]::SetEnvironmentVariable('TENANTRY_GITHUB_PAT', 'ghp_your_token', 'User')

Restart your terminal and IDE so they pick the variables up.

3. Add the packagesCopy Anchor Link

dotnet add package Tenantry.AspNetCore            # Tenantry core, from nuget.org
dotnet add package Tenantry.Pro                    # from the private feed
dotnet add package Tenantry.Pro.EfCore.SqlServer   # from the private feed

Getting started lists which packages each setup needs.

4. Configure the licence keyCopy Anchor Link

Pro reads the key you pass to pro.WithLicence(...). The examples in these docs read it from the configuration key Tenantry:Licence:

tenant.UsePro(pro =>
{
    pro.WithLicence(builder.Configuration["Tenantry:Licence"]!);
    // …
});

Keep the key out of source control. Locally, use user secrets:

dotnet user-secrets set "Tenantry:Licence" "<your licence key>"

Anywhere else, set the environment variable Tenantry__Licence (two underscores stand for the :), or use your secrets vault's configuration provider. Without a valid key the application does not start, so a missing key shows up straight away.

CICopy Anchor Link

Your pipeline needs the same two credentials to restore, and the licence key if it runs the application or its integration tests. Store them as secrets.

In GitHub Actions, a workflow's own GITHUB_TOKEN cannot read packages from another organisation's private feed, so pass the token as a secret:

jobs:
  build:
    runs-on: ubuntu-latest
    env:
      TENANTRY_GITHUB_USERNAME: ${{ vars.TENANTRY_GITHUB_USERNAME }}
      TENANTRY_GITHUB_PAT: ${{ secrets.TENANTRY_GITHUB_PAT }}
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-dotnet@v4
        with:
          dotnet-version: 10.0.x
      - run: dotnet restore
      - run: dotnet build --no-restore
      - run: dotnet test --no-build
        env:
          Tenantry__Licence: ${{ secrets.TENANTRY_LICENCE }}

Other CI systems work the same way: set TENANTRY_GITHUB_USERNAME and TENANTRY_GITHUB_PAT for the restore, and Tenantry__Licence for anything that starts the application.

In a Docker build, pass the token as a build secret rather than a build argument, so it is not kept in an image layer:

RUN --mount=type=secret,id=tenantry_pat,env=TENANTRY_GITHUB_PAT \
    TENANTRY_GITHUB_USERNAME=your-github-username dotnet restore

docker build --secret id=tenantry_pat,env=TENANTRY_GITHUB_PAT .

Rotating credentialsCopy Anchor Link

Access to the feed follows one GitHub account per subscription: the one connected on the Pro access page. For CI, use a token from that account (or connect a dedicated machine account and use its token).

When your subscription endsCopy Anchor Link

The connected account is removed from tenantry-org, so restores from the private feed fail. The versions you already have keep working with your key. If you need to rebuild after the subscription ends, keep copies of the packages you use, for example in your own internal feed or a committed local package folder.

TroubleshootingCopy Anchor Link

See alsoCopy Anchor Link

• Getting started — which packages to install, and building a first app.
• Licensing — how the key is validated, and what happens when a subscription ends.