# Jetify > Documentation for Jetify --- # Jetify Documentation Source: https://www.jetify.com/docs/llms-full.txt --- --- # Authenticating with the Cache Source: https://www.jetify.com/docs/docs/cloud/cache/authenticating/index Your Jetify Cloud organization is automatically provisioned with a shared cache. Any developers invited to your Jetify Cloud org will be automatically authenticated with the cache when they sign in. ## Managing Access to the Cache[](#managing-access-to-the-cache "Direct link to Managing Access to the Cache") Team members can be added in one of two Roles, which controls their access to the Jetify Build Cache. * **Members** have read-only access to the cache, and cannot push new packages * **Admins** have full read/write access to the cache, and can push new packages. You can add or remove team members from your team, or modify their role, using the [Jetify Cloud Dashboard](/docs/cloud/dashboard/inviting-members/) ## Authenticating from the CLI[](#authenticating-from-the-cli "Direct link to Authenticating from the CLI") Once you’ve been invited to a team, you can authenticate from the CLI by running: ```bash theme={null} devbox auth login ``` This will launch a browser window where you can authenticate with an email address or via Google SSO. You can check your current authentication status by running: ```bash theme={null} devbox auth whoami ``` You can check that you are connected to the cache, and your current cache URL, by running: ```bash theme={null} devbox cache info ``` You can logout by running: ```bash theme={null} devbox auth logout ``` ### Authenticating CI or Build Hosts[](#authenticating-ci-or-build-hosts "Direct link to Authenticating CI or Build Hosts") Admin users can generate Personal Access Tokens to authenticate on hosts where you cannot login via the CLI or Browser. This token will have the same push/pull permissions as the account that generated it. Treat your Personal Access Token as a password — keep it secret and secure, and do not share it with other users. To generate a Token, first authenticate as described above, and then run: ```bash theme={null} devbox auth tokens new ``` To authenticate with the personal access token, export it as an environment variable on your host: ``` export DEVBOX_API_TOKEN= ``` --- # Caching and Sharing Packages with Jetify Source: https://www.jetify.com/docs/docs/cloud/cache/index The provides teams with a private, secure Nix package cache that makes it easy to share packages across all your projects and users. With the Jetify cache, you never have to rebuild a package, even if it's removed from the official . If you want to use the Jetify Cache, you will need to add a payment option and upgrade your account to a Solo Plan or higher. For more details, see our [Plans and Pricing](https://www.jetify.com/cloud/pricing). Jetify Cache provides the following features: * **Fast package installations**: Devbox is optimized for downloading and installing packages from the Jetify cache, and it can bypass costly Nix evaluation steps when installing your packages. * **Integrates seamlessly with Devbox**: Devbox automatically configures access to the cache once users sign in, and packages are automatically pulled from the cache when running `devbox shell`, `devbox run`, or other commands. * **Integrates with CI/CD**: Jetify Cache can generate a secure token for securely pushing and pulling packages in CI/CD. * **Simple Access Control**: Devbox makes it easy to restrict which users can write to the cache, and makes it easy to revoke access directly from the dashboard. Jetify also supports Single Sign On for Enterprise Cache users ## Guides[](#guides "Direct link to Guides") * [Setting Up Jetify Cache](/docs/cloud/cache/authenticating/) * [Pushing and Pulling Packages from the Cache](/docs/cloud/cache/usage/) * [Using the Jetify Prebuilt Cache](/docs/cloud/cache/prebuilt-cache/) --- # Using the Jetify Prebuilt Cache Source: https://www.jetify.com/docs/docs/cloud/cache/prebuilt-cache/index The Jetify Prebuilt Cache provides users with prebuilt binaries of popular packages for the most common OS(Linux, macOS) + Architecture (x86-64, aarch64) combinations. The Jetify Prebuilt cache is intended to supplement the official NixOS Cache, and includes packages which are not available by default. This includes: 1. Older packages that have been garbage collected 2. Packages which have not been built for certain platforms 3. Packages with unfree licenses, which are not automatically built by NixOS ## Using the Prebuilt Cache[](#using-the-prebuilt-cache "Direct link to Using the Prebuilt Cache") The Prebuilt Cache is available for free to every developer who signs up for a Jetify Cloud account. Devbox will automatically configure itself to use the Prebuilt Cache when you login with `devbox auth login`: no additional action or steps are required. Free Jetify Cloud accounts are restricted to a **25 GB per month** download limit, and cannot generate access tokens for the cache. Solo, Starter, and Scaleup accounts have unlimited access to the Prebuilt Cache. ## Packages included in the Prebuilt Cache[](#packages-included-in-the-prebuilt-cache "Direct link to Packages included in the Prebuilt Cache") Some of the packages included in the Prebuilt Cache are: * MongoDB * Terraform * Vault * DynamoDB local * Pulumi * Helm * Unrar * Graphite More packages are added regularly. If you encounter a package that you think should be in the Prebuilt Cache, notify us on our [Discord](https://discord.gg/jetify). --- # Pushing and Pulling Packages to the Cache Source: https://www.jetify.com/docs/docs/cloud/cache/usage/index ## Pulling Packages from the Cache[](#pulling-packages-from-the-cache "Direct link to Pulling Packages from the Cache") Once you have authenticated, Devbox will automatically configure your cache for you. You can also manually configure the cache by running: ```bash theme={null} devbox cache configure ``` Once configured, Devbox will attempt to use the cache whenever you run a command that prompts Devbox to install a package in your project. When installing a package, Devbox will check for a cached binary in the following locations: 1. Your local Nix Store `/nix/store` 2. The Jetify Cache 3. The Public Nix Cache ([cache.nixos.org](https://cache.nixos.org)) If the package is not available in those locations, then it will build the package from source. ## Pushing to the Cache[](#pushing-to-the-cache "Direct link to Pushing to the Cache") You can push custom packages and project closures to your Jetify Cache directly from the Devbox CLI. Push access is currently only available for authenticated users with Admin permissions. ### **Pushing a Devbox Project**[](#pushing-a-devbox-project "Direct link to pushing-a-devbox-project") You can push the entire closure of a Devbox project to the Jetify Cache by navigating to your project root and running ```bash theme={null} devbox cache upload ``` ### Pushing a specific package[](#pushing-a-specific-package "Direct link to Pushing a specific package") You can also push a single package by passing a flake reference to the Devbox CLI. For example, to push a custom `mongodb` package from a custom flake.nix on your machine, you can run: ```bash theme={null} devbox cache upload path:./path/to/flake.nix#mongodb ``` You can also cache packages from Github or from Nixpkgs by passing the appropriate Flake reference. This can be useful for caching build artifacts if a package does not exist in the public Nix cache, or if it requires you to build it from source: ```bash theme={null} --- # Cache an installable hosted on Github (process-compose)devbox cache upload github:F1bonnac1/process-compose# Cache a package from nixpkgsdevbox cache upload nixpkgs#mongodb ``` --- # Creating Your Team Source: https://www.jetify.com/docs/docs/cloud/dashboard/creating-your-team/index Developers who want to use Jetify for their personal projects can sign up for a free account. The free account comes with basic Jetify Cloud features (like Secrets), with additional features like Deployments and Cache available for purchase. If you want to collaborate and share your projects with other members on your team, you will need to upgrade to a **Team Account**. Team accounts let you invite other developers to share resources and collaborate on projects in Jetify Cloud. Users with a free account can upgrade to a paid team on the dashboard anytime. ## Creating a New Team Account[](#creating-a-new-team-account "Direct link to Creating a New Team Account") 1. From the Team Selector in the top right of your dashboard, select **Create a New Team**

1. You may be prompted to sign in again. Log in with the same email or Google Account that you used to create your Account. 2. At the bottom of the team selection screen, enter your new Team Name and then click **Create Team** Create Team Form

1. Your new team will be created, and you will be automatically switched to your new team. You can now [invite other members](/docs/cloud/dashboard/inviting-members/) to join your team. ## Billing[](#billing "Direct link to Billing") Free accounts are free forever. You will need to add a payment method to unlock paid tier features. Team accounts are billed monthly based on the number of active members in your team. You can view your current billing status and update your billing information from the **Billing** tab in the Jetify Dashboard. --- # Introduction Source: https://www.jetify.com/docs/docs/cloud/dashboard/index The lets you manage your team, projects, and secrets from a single interface. You can use the Dashboard to manage your own hobby projects, or to collaborate with other team members.

You can visit the Jetify Dashboard at [cloud.jetify.com](https://cloud.jetify.com) ## Guides[](#guides "Direct link to Guides") * [Creating Your Team](/docs/cloud/dashboard/creating-your-team/) * [Inviting Members](/docs/cloud/dashboard/inviting-members/) * [Managing Jetify Secrets from the Dashboard](/docs/cloud/secrets/dashboard-secrets/) --- # Inviting your Team Members Source: https://www.jetify.com/docs/docs/cloud/dashboard/inviting-members/index If you have a paid Team project, you can invite team members to join your project. Team members can configure and use your project’s secrets when developing using the Devbox or Envsec CLI. If you want to invite team members to your projects, you will need to add a payment option and upgrade your account to a Starter Plan. For more details, see our [Plans and Pricing](https://www.jetify.com/cloud/pricing). Team members can be added in one of two Roles: * **Member:** Members can access or add projects, as well as access or modify the secrets for their projects * **Admins:** Have all the permissions of Members, but can also invite new team members and configure project billing ## Adding a Team Member[](#adding-a-team-member "Direct link to Adding a Team Member") 1. In the Jetify Dashboard, navigate to the **Members** tab Members Tab

2 . To invite a member, enter their email address, and the **Role** you want to assign to them. Inviting a Member

1. Once invited, users will receive an email with instructions on how to join your team. They will show up in the **Members** tab as invited until they accept the invitation: Invited Member

Note that invitations will expire if they are not accepted within 7 days, after which you will need to re-send the invitation. Once they accept the invitation, they will switch to **active** Active Member

## Removing a Team Member[](#removing-a-team-member "Direct link to Removing a Team Member") Removing a team member will remove their access to all projects and secrets in your team. To remove a team member 1. Navigate to the Members tab on the Jetify Dashboard 2. Click the Options button to the right of the member's name 3. Select Delete from the pop up that appears: Delete a member

1. Click **OK** on the confirmation window that appears to confirm that you want to remove the member from your team --- # Setting a Custom Domain for your Project Source: https://www.jetify.com/docs/docs/cloud/deploys/custom-domains/index Jetify Cloud will automatically configure a unique, private domain for previewing your deployed application. For production purposes, you will probably want to add a more user friendly domain to route users to your application. Jetify will also configure and issue an SSL certificate for your domain automatically. You will need access to the DNS records for your Domain in order to configure it for Jetify Cloud. ## Adding a Custom Domain[](#adding-a-custom-domain "Direct link to Adding a Custom Domain") 1. In your project on the Jetify Cloud Dashboard, select **Settings** 2. Scroll down to the **Custom Domain** section on the settings page Custom Domain Section

3. Enter the custom domain name that you would like to use for your project 4. After you click confirm, your custom domain will be set in a pending state. To validate the domain, you will need to add a record to your DNS provider: Pending custom domain

5. Once the correct records have been added to your DNS provider, your Custom Domain will display an **Issued** status: Custom Domain Issued

## Removing a Custom Domain[](#removing-a-custom-domain "Direct link to Removing a Custom Domain") You can remove a custom domain by clicking the Delete button. This will remove the domain from your project. Note that after removing the domain, you may want to also clean up your DNS records. --- # Introduction Source: https://www.jetify.com/docs/docs/cloud/deploys/index Jetify Deployments is an easy, Devbox friendly way to deploy a stateless application to the cloud in a few minutes. Jetify can build and run any Docker container, and provides easy tools for configuring your project's secrets, custom domains, and more. Jetify connects to your projects Github repo to ensure that you always have the latest version of your application deployed. If you want to invite team members to your projects, you will need to add a payment option and upgrade your account to a Solo Plan or higher. For more details, see our [Plans and Pricing](https://www.jetify.com/cloud/pricing). ## Quickstart[](#quickstart "Direct link to Quickstart") This quickstart will walk through how to configure and deploy a project with Jetify Cloud. We'll start by forking an example repo that is configured for Jetify Deployments, and then demonstrate how to connect your Github repo and activate deploys for your account. ## Forking the Example Repo[](#forking-the-example-repo "Direct link to Forking the Example Repo") To help you get started with Jetify Cloud, we've created an [example Rails app](https://github.com/jetify-com/jetify-deploy-example) that's been configured to deploy with Jetify Cloud. You can fork this repo from the Github UI to add it to your account, or clone and push the repo to your Github account. ## Connecting your Repo to Jetify Cloud[](#connecting-your-repo-to-jetify-cloud "Direct link to Connecting your Repo to Jetify Cloud") First, you'll need to sign-in with Github and connect your project to Jetify Cloud: 1. From the Create Project screen, select Continue with Github to sign in with Github 2. Select a Github Org to import your project from. If you are only a member of one org, it will be selected for you by default. 1. If this is your first time importing a project from your org, you will need to install the Devbox Cloud app to provide access to your project 3. Select a Repository to import your repo. If your project is not in the root directory of your repository, you can specify a subdirectory for Jetify to search for your project. Once your project is added to Jetify Cloud, you can configure your secrets or deployments. ## Deploying your Site[](#deploying-your-site "Direct link to Deploying your Site") 1. Select the Deploys tab in your project 2. Click the **Enable Deployments** button to turn on Jetify Deployments for your project 3. Once activated, Jetify will automatically attempt to deploy your repository. You can select the deployment to view its status and build logs If your site fails to deploy, or if you want to update your deployment, push a commit to the default branch of your repo to trigger a new deploy. ## Visiting your Site[](#visiting-your-site "Direct link to Visiting your Site") When your site has finished deploying, Jetify Cloud will display a preview URL that you can visit to test your application. Congratulations! You've now deployed your first site with Jetify Cloud. ## Next Steps[](#next-steps "Direct link to Next Steps") * Learn more about [setting up your project](/docs/cloud/deploys/setup/) * Set up a [custom domain](/docs/cloud/deploys/custom-domains/) for your application * Learn how to setup databases, caches, and other [integrations](/docs/cloud/deploys/integrations/) --- # Integration Guides Source: https://www.jetify.com/docs/docs/cloud/deploys/integrations/index This section contains guides on how to integrate common services with your Jetify deployments. * [PostgresQL with Supabase](/docs/cloud/deploys/integrations/supabase/) * [Redis with Upstash](/docs/cloud/deploys/integrations/upstash/) * [Object Storage with S3](/docs/cloud/deploys/integrations/s3/) --- # Monitoring Your Deployments Source: https://www.jetify.com/docs/docs/cloud/deploys/monitoring-deploys/index Jetify Cloud automatically provides build and runtime logs for each of your deployments in the Jetify Dashboard. ## Build Logs[](#build-logs "Direct link to Build Logs") Build logs include all the logs generated when cloning, building, and uploading your project to Jetify's Docker Registry. You can check the build logs to see why a build or deployment failed, or to identify bottlenecks in the build process. Build logs automatically stream in realtime. You can view the build logs for a specific deployment by selecting the deployment, and then expanding the Build logs section

## Runtime Logs[](#runtime-logs "Direct link to Runtime Logs") Runtime logs capture everything that has happened in your application after it is deployed to the Jetify Cloud. You can use these logs to for testing and debugging server-side errors, or for understanding why a given deployment has failed to start. Runtime logs stream in realtime, and Devbox retains the last 24 hours of runtime logs for each of your deployments. You can view your Runtime Logs by clicking the **Runtime Logs** tab in your Deployment Details page:

## Preview URL[](#preview-url "Direct link to Preview URL") In addition to build and runtime logs, Jetify Cloud automatically generates a randomized preview URL that you can use to test your application, or to share a preview of the deployment with other users and developers. Each deployment receives a unique preview URL. To preview your deployment, click the **View** button on the Deployment Details page. --- # Using Jetify Secrets with your Deployment Source: https://www.jetify.com/docs/docs/cloud/deploys/secrets/index Projects deployed with Jetify Cloud are automatically configured to use when deploying your project. You do not need to authenticate, or add any additional configuration to use your secrets. Your project will deploy using the environment for your secrets by default. For more details on how to configure secrets, see: * [Jetify Secrets Overview](/docs/cloud/secrets/) * [Setting Secrets from the CLI](/docs/cloud/secrets/secrets-cli/) * [Setting Secrets from the Dashboard](/docs/cloud/secrets/dashboard-secrets/) --- # Setting Up Your Deployment Source: https://www.jetify.com/docs/docs/cloud/deploys/setup/index ## Configuring your Project[](#configuring-your-project "Direct link to Configuring your Project") Deploying a project with Jetify Cloud requires the following: 1. **A devbox.json or Dockerfile**: If your project contains a `devbox.json` file, devbox will automatically generate a Dockerfile that can be used to deploy your application to Jetify Cloud. You can also check in a custom Dockerfile if you want to precisely control how your project is built 2. **A Service Listening on 8080**. Jetify automatically forwards requests to port 8080 on your running container, so you will need to ensure that your service is listening to that port. We also recommend setting your service host to `0.0.0.0`. ### Deploying with a devbox.json[](#deploying-with-a-devboxjson "Direct link to Deploying with a devbox.json") Jetify Cloud can use your `devbox.json` to generate a Docker container that will install your project dependencies and run your projects. In addition to installing your packages, Jetify will also look for and attempt to run any `install`, `build`, and `start` scripts defined in your devbox.json: * The **install script** will run after your base container has been initialized and your Nix packages are installed. This stage should be used to download and build your application's dependencies * The **build script** runs after the install stage, and should be used to build or bundle your application. * The **start script** will run as your container's entrypoint. This stage should include any commands needed to start and run your application. Below is an example `devbox.json` that can be used for a simple Go project in Jetify Cloud: ```json theme={null} { "packages": ["[email protected]"], "env": { "GOPATH": "$HOME/go/", "PATH": "$PATH:$HOME/go/bin" }, "shell": { "init_hook": ["export \"GOROOT=$(go env GOROOT)\""], "scripts": { "install": "go get ./...", "build": "go build -o main.go", "start": "go run", "run_test": "go run main.go" } } } ``` In this case, Jetify Cloud will first install Devbox and all the packages, then run the `install` and `build` scripts (in that order), and the use `start` as the entrypoint to the application. You can preview how Jetify will run the project using `devbox generate dockerfile --for prod` ### Deploying with a Custom Dockerfile[](#deploying-with-a-custom-dockerfile "Direct link to Deploying with a Custom Dockerfile") If your repo contains a Dockerfile, Jetify Cloud will use that Dockerfile to deploy your service (even if the project also contains a devbox.json). Your Dockerfile should define an entrypoint that Jetify can run upon deploying, as well as listen on port 8080. ## Connecting your Repo[](#connecting-your-repo "Direct link to Connecting your Repo") Jetify requires you to connect a Github repo in order to deploy your service. To access private repositories, you will need to install the Devbox Cloud Github app in your repository: 1. From the Create Project screen, select Continue with Github to sign in with Github 2. Select a Github Org to import your project from. If you are only a member of one org, it will be selected for you by default. 1. If this is your first time importing a project from your org, you will need to install the Devbox Cloud app to provide access to your project 3. Select a Repository to import your repo. If your project is not in the root directory of your repository, you can specify a subdirectory for Jetify to search for your project. Select the Repo for your Jetify Project

## Choosing an Instance Size[](#choosing-an-instance-size "Direct link to Choosing an Instance Size") Jetify will default your deployment to the smallest instance size (0.1 CPU + 512MB RAM). To choose a different size: 1. Navigate to the **Settings** tab of your project 2. Scroll down to **Deployments** 3. Choose the Machine configuration that best matches your project's needs. Changes to your instance size will take effect on the next deployment. ## Deleting your Project[](#deleting-your-project "Direct link to Deleting your Project") If you no longer want to deploy your project with Jetify Deploys, you can disable deployments in the Settings tab of your project. --- # Frequently Asked Questions Source: https://www.jetify.com/docs/docs/cloud/faq/index This doc contains answers to frequently asked questions about Jetify Cloud that are not covered elsewhere in our documentation. If you have a question that isn't covered here, feel free to ask us on our ## Do I have to pay to use Jetify Cloud?[](#do-i-have-to-pay-to-use-jetify-cloud "Direct link to Do I have to pay to use Jetify Cloud?") Jetify accounts are free for individual developers, and includes access to Jetify Secrets and the Jetify Prebuilt Cache. Using Jetify with a team requires a paid Jetify Solo, Starter, or Scale-up account. For details on other plans and limits, see our [**pricing**](https://www.jetify.com/cloud/pricing) page. ## How can I share my Jetify Cloud project with other developers?[](#how-can-i-share-my-jetify-cloud-project-with-other-developers "Direct link to How can I share my Jetify Cloud project with other developers?") To share secrets and access to deployments with other team members, you will need to create a new Jetify Starter Team and then invite developers to join your team. See the [cloud dashboard docs](/docs/cloud/dashboard/creating-your-team/) for more details. ## How do Jetify Cloud Plans work?[](#how-do-jetify-cloud-plans-work "Direct link to How do Jetify Cloud Plans work?") Jetify Cloud Plans are available for a monthly platform fee, and allow you to share your Jetify Cloud resources with your team, along with increased support levels. All plans include usage credits equal to the monthly platform fee, which are billed at standard usage rates. For more details, see our [**pricing**](https://www.jetify.com/cloud/pricing) page. ## Do you offer self-hosted or private instances of Jetify Cloud?[](#do-you-offer-self-hosted-or-private-instances-of-jetify-cloud "Direct link to Do you offer self-hosted or private instances of Jetify Cloud?") We offer private instances and other features as part of our Enterprise Plan. [Contact us](https://calendly.com/d/3rd-bhp-qym/meet-with-the-jetify-team) so we can build a solution that meets your needs. ## How does pricing for Jetify Cache work?[](#how-does-pricing-for-jetify-cache-work "Direct link to How does pricing for Jetify Cache work?") The Jetify Prebuilt Cache is included in your subscription for no additional cost. Jetify Private Cache costs $0.60/GB of storage per month for the first 50 GB, and $0.50/GB per month after that. Jetify Private cache does not charge for bandwidth or downloads. ## My project needs a custom instance size or scaling policy[](#my-project-needs-a-custom-instance-size-or-scaling-policy "Direct link to My project needs a custom instance size or scaling policy") We can customize Jetify Deployments for your project's needs. [Contact us](https://calendly.com/d/3rd-bhp-qym/meet-with-the-jetify-team) for help with a customized solution. --- # Cloud Documentation Source: https://www.jetify.com/docs/docs/cloud/index Jetify Cloud gives your team the tools and frameworks to accelerate your development workflow. Jetify Cloud is built on top of , a powerful tool for spinning up reproducible, isolated development environments on any machine. Jetify Cloud is currently available in Early Access. We're actively working on adding new features and improving the platform. To learn more, share your feedback, or follow our progress, join our [Discord Channel](https://discord.gg/jetify). Jetify Cloud currently includes: **[Jetify Cache](/docs/cloud/cache/)**: Provides a secure, private cache to share packages across all your Devbox projects and environments, whether sourced from Nixpkgs or Flakes. Avoid rebuilding custom packages locally or in CI. **[Jetify Secrets](/docs/cloud/secrets/)**: Securely store secrets and variables for all of your environments, and automatically synchronize them with your Devbox Shells and Scripts. More features are coming soon, keep an eye on our [**blog**](https://www.jetify.com/blog) for future updates! ## Getting Started[](#getting-started "Direct link to Getting Started") * Speed up your dev environments with [**Jetify Cache**](/docs/cloud/cache/) * Integrate Secrets with your Devbox project using [**Jetify Secrets**](/docs/cloud/secrets/) * Learn how to [**create your team**](/docs/cloud/dashboard/creating-your-team/) and [**invite members**](/docs/cloud/dashboard/inviting-members/) --- # Managing Secrets from the Dashboard Source: https://www.jetify.com/docs/docs/cloud/secrets/dashboard-secrets/index You can add or manage secrets for a Jetify Cloud project using the Secrets tab of the Jetify Dashboard. Secrets that you set in the Dashboard will be automatically available when an authenticated member of your team uses Devbox to start a shell, script, or service in the application. ## Prerequisites[](#prerequisites "Direct link to Prerequisites") To manage secrets from the Jetify Cloud Dashboard, you must first: 1. Add the project to your Jetify Cloud account 2. Initialize the project to use Jetify Secrets ## Adding a Secret[](#adding-a-secret "Direct link to Adding a Secret") 1. From the Jetify Dashboard, select the project whose secrets you want to manage 2. Navigate to the Secrets tab of the Jetify Dashboard Jetify Dashboard Secrets Tab

3. To create a new secret, enter the key name of the secret, along with the value that you want to set in the form. Note that secrets are set as environment variables, so the key name must be a valid environment variable name. 4. You can also use the Environment checkboxes to set the secret for a specific environment. By default, secrets are set for the `Development` environment, but you can also set secrets for a `Preview` and `Prod` environment. 5. To add multiple secrets at one time, click the **Add Another** button 6. When you are finished adding secrets, click the **Submit** button ## Updating and Managing Secrets[](#updating-and-managing-secrets "Direct link to Updating and Managing Secrets") You can update or manage secrets by clicking the edit button next to the secret that you want to update. This will open a modal where you can update the value of the secret, or delete the secret entirely. Editing Secrets

## Further Reading[](#further-reading "Direct link to Further Reading") * [Managing Secrets with the Devbox CLI](/docs/cloud/secrets/secrets-cli/) --- # Introduction Source: https://www.jetify.com/docs/docs/cloud/secrets/index Jetify Secrets is a secure secrets management service that lets you store and access secrets for your projects. Secrets are encrypted and stored in the cloud, and are automatically accessed by your project's Devbox environment whenever you start a shell, run a script, or start a service. ## Key Concepts[](#key-concepts "Direct link to Key Concepts") Jetify provides an easy way to manage secrets for your projects. To get started, it’s helpful to understand the following key concepts: **Project** - A Jetify project is a git repo that contains a `devbox.json` file. You can add a project to your Jetify Cloud account by running `devbox secrets init` in the root of your project. Once a project is added to your Jetify Cloud account, you can use Jetify Secrets to manage secrets for that project. **Secrets** - Secrets are key-value pairs that are stored securely in the Jetify Secret store. They automatically set as environment variables in your Devbox project whenever you start a shell, run a script, or start a service. Secrets are encrypted at rest and in transit, and are only decrypted when they are accessed by your Devbox environment or by a user in your Jetify Cloud team. **Environment** - An environment is a set of secrets that are available to your project. By default, all secrets are set on the `Development` environment, but Devbox also lets you set secrets for a `Preview` and `Production` environment. Starting a shell or running a script in a specific environment gives you access to all the secrets that are set for your environment. ## Getting Started[](#getting-started "Direct link to Getting Started") To learn how to set secrets from the Jetify Dashboard, see our [Dashboard Secrets](/docs/cloud/secrets/dashboard-secrets/) guide. To learn how to use your Secrets with Devbox and manage your secrets from the command line, see our [Secrets CLI Guide](/docs/cloud/secrets/secrets-cli/). --- # Managing Secrets with the Devbox CLI Source: https://www.jetify.com/docs/docs/cloud/secrets/secrets-cli/index You can access your Jetify Secrets locally using Devbox. When you authenticate your Devbox CLI with Jetify Cloud, Devbox will automatically identify your project, and make your secrets available in your Devbox shell. Developers who are part of your Jetify Cloud team can also access your project’s secrets automatically, whenever they use devbox to start a shell, run a script, or launch a service If you don't already have Devbox installed, see our [Quickstart](https://www.jetify.com/docs/devbox/quickstart/) guide to get started. ## Authenticating with Devbox[](#authenticating-with-devbox "Direct link to Authenticating with Devbox") You can authenticate with Jetify Cloud by running `devbox auth login`. This will launch the browser authentication flow to sign into Jetify Cloud. Auth Page

Once you complete the authentication flow and select a team, the Devbox CLI will configure itself to use the team you selected ## Integrating a project with devbox secrets[](#integrating-a-project-with-devbox-secrets "Direct link to Integrating a project with devbox secrets") To create a new project on Jetify Cloud, navigate to the root directory of your project and run `devbox secrets init` ```bash theme={null} /Users/puckworth/my-project❯ devbox secrets init ? Setup project in /Users/puckworth/my-project? Yes Initializing project in org ? What's the name of your new project? my-test-project Created project my-test-project in org ``` Running `devbox secrets init` will create a new project in your current Jetify Cloud account and org, and configure your project to use Jetify Secrets. The project should also be visible if you navigate to the [Jetify Dashboard](/docs/cloud/dashboard/). ## Adding Secrets to your Project[](#adding-secrets-to-your-project "Direct link to Adding Secrets to your Project") ### Adding Secrets from the Command Line[](#adding-secrets-from-the-command-line "Direct link to Adding Secrets from the Command Line") You can set secrets using `devbox secrets set`: ```bash theme={null} devbox secrets set FOO=BAR ``` ```text theme={null} [DONE] Set environment variable 'FOO' in environment: dev ``` By default, variables will be set on the `dev` environment. You can set secrets on other environments by passing the `--environment` flag: ```bash theme={null} devbox secrets set FOO=BAR --environment prod ``` Supported environments include `dev`, `preview`, and `prod`. ### Adding Secrets from a File[](#adding-secrets-from-a-file "Direct link to Adding Secrets from a File") You can bulk add secrets from a file by using `devbox secrets import`: ```bash theme={null} devbox secrets import .env.dev [DONE] Uploaded 3 environment variable(s) from file '.env.dev' to environment: dev ``` The file should follow the `.env` format, with each line containing a single environment variable in the form: ```bash theme={null} VARIABLE_NAME=VARIABLE_VALUE ``` ## Viewing your Project's Secrets You can view your project's secrets by running `devbox secrets ls`: ```text theme={null} Environment: dev +-----------------+-------+ | NAME | VALUE | +-----------------+-------+ | FOO | ***** | | DEV_SERVER | ***** | | PG_PASSWORD | ***** | +-----------------+-------+ Environment: prod +-----------------+-------+ | NAME | VALUE | +-----------------+-------+ | FOO | ***** | | PG_PASSWORD | ***** | +-----------------+-------+ Environment: preview +-----------------+-------+ | NAME | VALUE | +-----------------+-------+ | FOO | ***** | | PG_PASSWORD | ***** | +-----------------+-------+ ``` ## Accessing your Secrets from a Devbox Shell[](#accessing-your-secrets-from-a-devbox-shell "Direct link to Accessing your Secrets from a Devbox Shell") Once your project is configured for Jetify Cloud, Devbox will automatically check whether the project exists in your Jetify Cloud account based on: 1. Your current project’s Git repository 2. The subfolder where your `devbox.json` is located If you have a matching project in your Jetify Cloud account, Devbox will automatically set your secrets as environment variables whenever you: 1. Start a `devbox shell` 2. Start services with `devbox services up` or `devbox services start` 3. Run a script with `devbox run` ## Removing a Secret from your Project[](#removing-a-secret-from-your-project "Direct link to Removing a Secret from your Project") You can remove a secret from your project by running `devbox secrets rm`: ```bash theme={null} devbox secrets rm FOO [DONE] Deleted environment variable 'FOO' in environment: dev ``` ## Exporting Secrets to a File[](#exporting-secrets-to-a-file "Direct link to Exporting Secrets to a File") You can export your secrets to a `.env` file using `devbox secrets download`: ```bash theme={null} devbox secrets download .env [DONE] Downloaded environment variables to '.env' for environment: dev ``` You can download from a specific environment using the `--environment` flag: ## Further Reading[](#further-reading "Direct link to Further Reading") * [Devbox Secrets CLI Reference](/docs/devbox/cli-reference/devbox-secrets/) * [Managing Secrets from the Dashboard](/docs/cloud/secrets/dashboard-secrets/) --- # devbox add Source: https://www.jetify.com/docs/docs/devbox/cli-reference/devbox-add/index Add a new package to your devbox ```bash theme={null} devbox add ... [flags] ``` ## Examples[](#examples "Direct link to Examples") ```bash theme={null} --- # Add the latest version of the `ripgrep` package devbox add ripgrep --- # Install glibcLocales only on x86_64-linux and aarch64-linux devbox add glibcLocales --platform x86_64-linux,aarch64-linux --- # Exclude busybox from installation on macOS devbox add busybox --exclude-platform aarch64-darwin,x86_64-darwin --- # Install non-default outputs for a package, such as the promtool CLI devbox add prometheus --outputs=out,cli ``` ## Options[](#options "Direct link to Options") | Option | Description | | -------------------------------- | ---------------------------------------------------------------------------------------------------------------------- | | `--allow-insecure` | allows Devbox to install a package that is marked insecure by Nix | | `-c, --config string` | path to directory containing a devbox.json config file | | `--disable-plugin` | disable the build plugin for a package | | `--environment string` | Jetify Secrets environment to use, when supported (e.g.secrets support dev, prod, preview.) (default "dev") | | `-e, --exclude-platform strings` | exclude packages from a specific platform. | | `-h, --help` | help for add | | `-o, --outputs strings` | specify the outputs to install for the nix package | | `-p`, `--platform strings` | install packages only on specific platforms. | | `--patch` | Allow Devbox to patch your packages to fix issues with missing native libraries (auto, always, never) (default "auto") | | `-q, --quiet` | quiet mode: Suppresses logs. | Valid Platforms include: * `aarch64-darwin` * `aarch64-linux` * `x86_64-darwin` * `x86_64-linux` The platforms below are also supported, but will build packages from source * `i686-linux` * `armv7l-linux` ## SEE ALSO[](#see-also "Direct link to SEE ALSO") * [devbox](/docs/devbox/cli-reference/devbox/) - Instant, easy, predictable shells and containers [Edit this page](https://github.com/jetify-com/devbox/tree/main/docs/app/docs/cli-reference/devbox-add.md) --- # devbox cache configure Source: https://www.jetify.com/docs/docs/devbox/cli-reference/devbox-cache-configure/index Configure Nix to use the Devbox cache as a substituter. If the current Nix installation is multi-user, this command grants the Nix daemon access to Devbox caches by making the following changes: * Adds the current user to Nix's list of trusted users in the system nix.conf. * Adds the cache credentials to \~root/.aws/config. Configuration requires sudo, but only needs to happen once. The changes persist across Devbox accounts and organizations. This command is a no-op for single-user Nix installs that aren't running the Nix daemon. ```bash theme={null} devbox cache configure [flags] ``` ## Options[](#options "Direct link to Options") | Option | Description | | --------------- | --------------------------------------------------------------- | | `--user string` | The OS user to configure Nix for. Defaults to the current user. | | `-h, --help` | help for configure | | `-q, --quiet` | suppresses logs | [Edit this page](https://github.com/jetify-com/devbox/tree/main/docs/app/docs/cli-reference/devbox-cache-configure.md) --- # devbox cache info Source: https://www.jetify.com/docs/docs/devbox/cli-reference/devbox-cache-info/index Output information about the nix cache ```bash theme={null} devbox cache info [flags] ``` ## Options[](#options "Direct link to Options") | Option | Description | | ------------- | --------------- | | `-h, --help` | help for info | | `-q, --quiet` | suppresses logs | [Edit this page](https://github.com/jetify-com/devbox/tree/main/docs/app/docs/cli-reference/devbox-cache-info.md) --- # devbox cache upload Source: https://www.jetify.com/docs/docs/devbox/cli-reference/devbox-cache-upload/index Upload specified nix installable or nix packages in current project to cache. If [installable] is provided, only that installable will be uploaded. Otherwise, all packages in the project will be uploaded. To upload to specific cache, use --to flag. Otherwise, a cache from the cache provider will be used, if available. ```bash theme={null} devbox cache upload [installable] [flags] ``` ## Aliases[](#aliases "Direct link to Aliases") upload, copy ## Options[](#options "Direct link to Options") | Option | Description | | --------------------- | ------------------------------------------------------ | | `-c, --config string` | path to directory containing a devbox.json config file | | `-h, --help` | help for upload | | `--to string` | URI of the cache to copy to | | `-q, --quiet` | suppresses logs | [Edit this page](https://github.com/jetify-com/devbox/tree/main/docs/app/docs/cli-reference/devbox-cache-upload.md) --- # devbox cache Source: https://www.jetify.com/docs/docs/devbox/cli-reference/devbox-cache/index A collection of commands to interact with the Jetify Cache or other Nix caches. ```bash theme={null} devbox cache [command] ``` ## Subcommands[](#subcommands "Direct link to Subcommands") info Output information about the nix cache upload specified or nix packages in current project to cache ## Options[](#options "Direct link to Options") | Option | Description | | ------------- | --------------- | | `-h, --help` | help for cache | | `-q, --quiet` | suppresses logs | [Edit this page](https://github.com/jetify-com/devbox/tree/main/docs/app/docs/cli-reference/devbox-cache.md) --- # devbox completion bash Source: https://www.jetify.com/docs/docs/devbox/cli-reference/devbox-completion-bash/index Generate the autocompletion script for the bash shell. This script depends on the 'bash-completion' package. If it is not installed already, you can install it via your OS's package manager. To load completions in your current shell session: ```bash theme={null} source <(devbox completion bash) ``` To load completions for every new session, execute once: ## Linux[](#linux "Direct link to Linux") ```bash theme={null} devbox completion bash > /etc/bash_completion.d/devbox ``` ## macOS[](#macos "Direct link to macOS") ```bash theme={null} devbox completion bash > \ $(brew --prefix)/etc/bash_completion.d/devbox ``` You will need to start a new shell for this setup to take effect. ```bash theme={null} devbox completion bash ``` ## Options[](#options "Direct link to Options") | Option | Description | | ------------------- | ------------------------------- | | `-h, --help` | help for bash | | `--no-descriptions` | disable completion descriptions | | `-q, --quiet` | suppresses logs | ## SEE ALSO[](#see-also "Direct link to SEE ALSO") * [devbox completion](/docs/devbox/cli-reference/devbox-completion/) - Generate the autocompletion script for the specified shell [Edit this page](https://github.com/jetify-com/devbox/tree/main/docs/app/docs/cli-reference/devbox-completion-bash.md) --- # devbox completion fish Source: https://www.jetify.com/docs/docs/devbox/cli-reference/devbox-completion-fish/index Generate the autocompletion script for the fish shell. To load completions in your current shell session: ```bash theme={null} devbox completion fish | source ``` To load completions for every new session, execute once: ```bash theme={null} devbox completion fish > ~/.config/fish/completions/devbox.fish ``` You will need to start a new shell for this setup to take effect. ```bash theme={null} devbox completion fish [flags] ``` ## Options[](#options "Direct link to Options") | Option | Description | | ------------------- | ------------------------------- | | `-h, --help` | help for fish | | `--no-descriptions` | disable completion descriptions | | `-q, --quiet` | suppresses logs | ## SEE ALSO[](#see-also "Direct link to SEE ALSO") * [devbox completion](/docs/devbox/cli-reference/devbox-completion/) - Generate the autocompletion script for the specified shell [Edit this page](https://github.com/jetify-com/devbox/tree/main/docs/app/docs/cli-reference/devbox-completion-fish.md) --- # devbox completion zsh Source: https://www.jetify.com/docs/docs/devbox/cli-reference/devbox-completion-zsh/index Generate the autocompletion script for the zsh shell. If you are using Oh My Zsh, just run the following: ```bash theme={null} mkdir -p ~/.oh-my-zsh/completions devbox completion zsh > ~/.oh-my-zsh/completions/_devbox ``` If you are not using Oh My Zsh and shell completion is not already enabled in your environment you will need to enable it. You can execute the following once: ``` echo "autoload -U compinit; compinit" >> ~/.zshrc ``` To load completions in your current shell session: ```bash theme={null} source <(devbox completion zsh); compdef _devbox devbox ``` To load completions for every new session, execute once: ## Linux[](#linux "Direct link to Linux") ```bash theme={null} devbox completion zsh > "${fpath[1]}/_devbox" ``` ## macOS[](#macos "Direct link to macOS") ```bash theme={null} devbox completion zsh > \ $(brew --prefix)/share/zsh/site-functions/_devbox ``` You will need to start a new shell for this setup to take effect. ```bash theme={null} devbox completion zsh [flags] ``` ## Options[](#options "Direct link to Options") | Option | Description | | ------------------- | ------------------------------- | | `-h, --help` | help for zsh | | `--no-descriptions` | disable completion descriptions | | `-q, --quiet` | suppresses logs | ## SEE ALSO[](#see-also "Direct link to SEE ALSO") * [devbox completion](/docs/devbox/cli-reference/devbox-completion/) - Generate the autocompletion script for the specified shell [Edit this page](https://github.com/jetify-com/devbox/tree/main/docs/app/docs/cli-reference/devbox-completion-zsh.md) --- # devbox completion Source: https://www.jetify.com/docs/docs/devbox/cli-reference/devbox-completion/index Generate the autocompletion script for the specified shell ## Synopsis[](#synopsis "Direct link to Synopsis") Generate the autocompletion script for devbox for the specified shell. See each sub-command's help for details on how to use the generated script. ## Options[](#options "Direct link to Options") | Option | Description | | ------------- | ------------------- | | `-h, --help` | help for completion | | `-q, --quiet` | suppresses logs | ## SEE ALSO[](#see-also "Direct link to SEE ALSO") * [devbox](/docs/devbox/cli-reference/devbox/) - Instant, easy, predictable development environments * [devbox completion bash](/docs/devbox/cli-reference/devbox-completion-bash/) - Generate the autocompletion script for bash * [devbox completion fish](/docs/devbox/cli-reference/devbox-completion-fish/) - Generate the autocompletion script for fish * [devbox completion zsh](/docs/devbox/cli-reference/devbox-completion-zsh/) - Generate the autocompletion script for zsh [Edit this page](https://github.com/jetify-com/devbox/tree/main/docs/app/docs/cli-reference/devbox-completion.md) --- # devbox create Source: https://www.jetify.com/docs/docs/devbox/cli-reference/devbox-create/index Initialize a directory as a devbox project using a template ## Synopsis[](#synopsis "Direct link to Synopsis") Initialize a directory as a devbox project. This will create an empty devbox.json in the current directory. You can then add packages using `devbox add` ```bash theme={null} devbox create [dir] --template