Good to know

What to know before you deploy Tailscale

The Tailscale stack deploys one app service: a persistent Tailscale node that joins your tailnet. Creating the app requires a Tailscale integration with the Tailscale Node type, which you set up beforehand.

Create the integration first

Set up Tailscale and create the Tailscale Node integration before you create the app. Wodby then issues a scoped auth key that the node uses to join your tailnet.

Serving another service

An optional link, Service to serve, directs the node to a different service in the app environment. Since this stack has only the node, the link is meant for a custom stack that includes that service too.

Not for making endpoints private

A deployed node neither exposes other app services nor changes the environment's Access setting. If the goal is private HTTP endpoints, choose Private App Access rather than this stack.

Read the Tailscale stack guide for setup steps, settings, and limits.

Services

Start with the right services, then make the stack your own

The Tailscale stack comes with these services already connected. The table shows which ones are enabled by default when you create an app environment and, where services depend on each other, how they are linked.

When you add the stack to your organization, the copy is yours to change. Changes go into a draft that you publish as a new stack revision, and app environments pick them up when they upgrade.

Add services

Add any service from the catalog, such as a cache, a search engine, or a mail relay, and link it to the services that use it.

Remove what you do not need

Leave optional services out when you create an app, disable a service in one app environment, or remove it from the stack for every environment.

Change how services connect

Point a link at another service in the stack or, where the link allows it, at a service of another app or at custom values such as a managed database. Change it for the whole stack or for one app environment.

Stack serviceBase serviceRole
Tailscale
TailscaleRequired

Explore the full stack service catalog for configs, settings, actions, cron, volumes, links, backups, and imports attached to each service in this stack. The stack configuration guide covers adding services, removing them, and changing links.

Deploy

Choose where it runs. Wodby maintains it either way.

The application stack stays the same on Wodby Cloud, in your own cloud account, or on your own server. Wodby keeps Kubernetes, the cluster infrastructure, and the stack up to date wherever it runs, so the choice comes down to where you want the resources and what you want to pay.

Wodby Cloud

Wodby hosts the cluster, so there is no cloud account or server to set up first.

Your cloud account

Keep the cluster and its resources in your own cloud account. Wodby creates it and keeps it up to date.

Server or dedicated host

Run the same stack on a VM, bare-metal server, or dedicated host at the lowest cost. Wodby checks its packages for vulnerabilities and installs updates when you choose.

Explore hosting options for this stack to compare managed cloud, customer-cloud, and server-based deployment models in more detail.

Integrations

Connect the stack to private networking integrations

Keep private networking integrations attached to the stack instead of reconnecting tailnets and related access per environment.

That makes it easier to bring new environments and related workloads into the same private network without rebuilding the connection model.

Supported private networking providers

Explore all integrations for this stack to browse private networking providers supported by this stack.

Git-managed configuration

Keep your stack configuration in Git

Store the application blueprint in a stack.yml template alongside your code. Version service definitions, defaults, settings, and environment behavior while Wodby turns approved source changes into controlled stack revisions.

Version the application blueprint

Review stack configuration through commits and pull requests before it reaches an environment.

Import updates as new revisions

Follow an approved branch or semantic-version tags without changing running app environments in place.

Keep service updates enabled

Control Git template updates and service auto-updates separately, so customized stacks can still receive eligible releases.

Explore Git-backed stacks and see how they work with automatic updates.

Security and maintenance

Stay secure with automatic service updates

Enable service auto-updates at stack level to pick up eligible security patches and maintenance releases. Wodby creates a new stack revision instead of changing running app environments in place, so every update stays visible and reviewable.

Choose which app environments should auto-upgrade and limit production rollouts to a local-time maintenance window. Development and staging can move sooner while production follows your security and maintenance policy.

Explore automatic updates to see how policies, revisions, maintenance windows, and app environment auto-upgrades work.

Observability and debugging

Understand what running services are doing

Keep the signals and tools for day-to-day troubleshooting close to each app environment, from a quick health check to direct inspection inside a running container.

Stream live container logs

Follow app service output in real time and select a specific workload or container when a service exposes more than one.

Track runtime health

Inspect app environment and service metrics for CPU, memory, storage, readiness, and restarts before changing resources or scaling.

Debug with a web terminal

Open an interactive shell in a running service container for quick inspection and one-off commands without exposing a public SSH port.

Explore observability for logs and metrics, or review service configuration for web terminal access and other runtime operations.

Environments

Create development, staging, and production environments

Launch development, staging, production, or customer-specific environments from the same Tailscale stack, then tailor values and configuration to each one.

Start from a consistent baseline

Use the same enabled services and integrations across development, staging, and production.

Customize each environment

Override values, configs, and settings without changing the shared stack definition.

Explore environments for development, staging, and production workflows.

Get started

Create a new Tailscale environment

Reuse the same stack across app environments without rebuilding the definition for every new environment.

FAQ

Common questions about the Tailscale stack

What does the Tailscale stack include?

Tailscale integration stack for private networking between apps, services, and operators. App environments created from this stack inherit the services enabled by default, attached integrations, hosting options, and stack revision history.

How can one stack support multiple apps and environments?

You can reuse the same stack for multiple similar apps and for development, staging, production, and other environment types. The stack defines the shared services and defaults, you can set different values for env types such as dev and prod, and each app environment can still be configured individually.

How do stack updates work?

When an included service gets an update, the stack can be marked as outdated or create a new revision automatically under its update policy. Existing app environments stay on their current revision until you upgrade them manually or enable stack auto-upgrades with a maintenance window.

How do integrations work with this stack?

Use the Integrations section to attach reusable connections created from supported providers. That keeps credentials, variables, and external services connected to the stack instead of configuring them separately for every app environment.

Can app environments from this stack run on different infrastructure?

Yes. Development and production app environments from the same stack can run on different hosting models, including Wodby Cloud, managed Kubernetes, and self-hosted Kubernetes on a VM or dedicated server, while keeping the same stack definition and upgrade path.