DEV Community: Rob Richardson

Deploy a Python App to Kubernetes in 5 Minutes with Jetpack.io

Rob Richardson — Mon, 12 Sep 2022 19:52:22 +0000

Deploying to Kubernetes is Hard

Maybe you can relate: We've finished coding a website, and we're ready to deploy. We know we want to deploy to Kubernetes, to take advantage of it's industrial-scale hosting, automatic load-balancing, fault tolerance, scaling, and more.

But deploying to Kubernetes is hard. Now we have to trek into the land of containers, pods, services, ingress, and yaml. Ugh. "I just finished the website. I don't want to read a book just to make it work." Kubernetes has too many options and concepts: Pods, Deployments, ReplicaSets, Services, ConfigMaps. Oh my! And the Kubernetes yaml file is really confusing and specific. I really wish it was easier to deploy a website to Kubernetes.

Why Jetpack.io

Jetpack.io is a zero-DevOps solution for deploying to Kubernetes. Jetpack.io takes your code, packages it up in a container, and publishes it to Kubernetes. Jetpack.io also creates a public URL so the site can be routable from the internet, and can stream application logs back to your terminal. All of the toil of Kubernetes melts away, and we can focus on our application.

This guide will teach you how to setup up the Jetpack backend development platform for the very first time, and how to build and deploy your first backend to a Kubernetes cluster in a matter of minutes.

You don't even need an existing Kubernetes cluster to get started – we'll give you access to a free cluster to get you up and running!

Install the Jetpack CLI

The Jetpack Command Line Interface (CLI) is a command-line tool that helps you create, build and deploy new backends directly from your terminal. It’s simple to install and works for both macOS and Linux.

To install it, run the install script:

curl https://get.jetpack.io -fsSL | bash

Validate the installation by running the jetpack version command

jetpack version

Login to Jetpack

Next, you'll sign-up for a new Jetpack Cloud account, which will grant you access to a free Kubernetes cluster and a container registry managed by us.

Run the following command to authenticate the CLI:

jetpack auth login

Create a new account by following the instructions in your browser, or if you already have an account, use your existing credentials to log in.

Your CLI is now linked to your account and it's ready to deploy new backends.

Clone Jetpack's quickstart project

Jetpack can deploy any containerized application to Kubernetes as an autoscaling, Kubernetes deployment. For this quickstart, we'll use a simple example FastAPI app from Jetpack's example repo.

git clone https://github.com/jetpack-io/jetpack-examples.git
cd jetpack-examples/01-py-fastapi-quickstart

Initialize your project

This launch a generator which will ask you a few questions to configure your project. For this quickstart, we'll choose the following options:

What is the name of this application? 01-py-fastapi-quickstart
Choose your project template Web Service (Since we're creating a web app with an API)
Would you like to use Jetpack's trial cluster, or your own Kubernetes cluster? jetpack-cloud (We'll use Jetpack's trial cluster)

Here's the output you'll see:

? What is the name of this application? test-app
? What type of application is this? Web Service
? Would you like to use Jetpack's trial cluster, or your own kubernetes cluster? jetpack-cloud

This will create a jetconifg.yaml in your project folder. This file has the basic configuration that Jetpack will use to deploy your project to Kubernetes. You should commit this file to source control.

Deploy to Kubernetes

Deploy the Test App with Jetpack Dev We are now ready to deploy our example app! We'll deploy using jetpack dev , which will stream our service's logs to our terminal and let us quickly redeploy any changes that we make.

From within the quickstart-project folder, run:

jetpack dev

This will create and build a Docker container for your project, push it to the container registry, and deploy it to the Kubernetes cluster. Once it finishes deploying, the CLI will stream your logs and port-forward from your local machine to the running container, so that you can test it live in the cluster:

[Done] App deployed
Attempting to port forward app...
The service will be accessible at http://localhost:8080
     - this port forwards to port 8080 on the pod
Attempting to port forward runtime...
The service will be accessible at http://localhost:8090
     - this port forwards to port 8080 on the pod
+ jetpack-runtime-7c46d5cd7b-d2ksj › jetpack-runtime
+ new-project-app-68b9f8cddf-xgpzg › app
new-project-app-68b9f8cddf-xgpzg app INFO:     Started server process [1]
new-project-app-68b9f8cddf-xgpzg app INFO:     Waiting for application startup.
new-project-app-68b9f8cddf-xgpzg app INFO:     Application startup complete.
new-project-app-68b9f8cddf-xgpzg app INFO:     Uvicorn running on http://0.0.0.0:8080 (Press CTRL+C to quit)

Test your Service When Jetpack finishes deploying, you can test the service at http://localhost:8080 using curl, httpie, or your browser:

curl localhost:8080

You should see the response:

<h1>Hello! Welcome to Jetpack</h1>

Well that was easy

It's easy to deploy a Python app to Kubernetes with Jetpack.io. In this tutorial we scaffolded a website, configured it for Jetpack.io, and used Jetpack.io to deploy to Kubernetes. Jetpack.io is a great zero-DevOps solution for deploying to Kubernetes. Visit https://jetpack.io/docs/ to learn more and to start deploying your content to Kubernetes with ease.

Deploy a JavaScript, Node.js, and Express Website to Kubernetes in 5 Minutes with Jetpack.io

Rob Richardson — Mon, 12 Sep 2022 19:36:51 +0000

Deploying to Kubernetes is Hard

Why Jetpack.io

Building an Express.js app with Node.js

In this example we'll quickly scaffold an Express website. You could swap out these steps with use an existing Node web site, or scaffold a site using other frameworks or tools.

Open a terminal in an empty directory.
Generate an Express website:

npx express-generator --view hbs

Now we have a regular Node.js website. Feel free to customize this site to meet your needs.

Configure the App for Containers

Jetpack.io assumes your web server is running on port 8080 from inside a Docker container. In this section we'll build a Dockerfile to run the web site on port 8080.

Create a new file in the folder named Dockerfile and add this content:

FROM node:alpine
WORKDIR /app
COPY . .
RUN npm install
ENV PORT=8080
EXPOSE 8080
CMD ["npm", "start"]

Note: this is a bare-bones Dockerfile. Depending on your app's dependencies, you may need to add more.

Initialize the project with Jetpack.io

Jetpack.io needs some initial configuration to understand the Node.js web server. We need only do this once per website.

To install the Jetpack CLI, open a terminal and run

curl https://get.jetpack.io -fsSL | bash

Jetpack CLI works on Linux, macOS, and on Windows via WSL2.

jetpack auth login

Logging into Jetpack allows you to deploy to the Jetpack.io Kubernetes cluster. You can also run on your own cluster in your Azure, AWS, GCP, or private cloud account.

Initialize the project for Jetpack:

jetpack init

This wizard interviews you and configures the Jetpack deployment strategy to match your application.

Answer that Yes, this is a web server. This tells Jetpack that we want to accept inbound traffic.

If we were building a scheduled cron job or a function that drained a queue, we could answer no.

Finish the wizard, and Jetpack CLI automatically generates an appropriate jetconfig.yaml file. You should commit this to source control.

Deploy to Kubernetes using Jetpack.io

Now that the project is configured for Jetpack, deploying is really easy.

Open a terminal in the directory with the Dockerfile and jetconfig.yaml file.
Deploy to Kubernetes:

jetpack dev

Now Jetpack makes the deployment really simple. Automatically it will:

Build the Docker image
Push the image to a private registry
Schedule the necessary Kubernetes resources
Create a publicly routable URL to test the website
Setup port-forwarding from your local machine
Stream application logs back to the terminal

Test the website:

In the console output will be the publicly routable URL. Click this URL to view the web page.

Jetpack also sets up port-forwarding, so you can also browse to http://localhost:8080/ to view the page.

Well that was easy

It's easy to deploy a Node.js and Express.js app built with JavaScript to Kubernetes with Jetpack.io. In this tutorial we scaffolded a website, configured it for Jetpack.io, and used Jetpack.io to deploy to Kubernetes. Jetpack.io is a great zero-DevOps solution for deploying to Kubernetes. Visit https://jetpack.io/docs/ to learn more and to start deploying your content to Kubernetes with ease.

Devbox 0.0.4 is released!

Rob Richardson — Thu, 08 Sep 2022 16:12:36 +0000

We’re excited to showcase the next release of Devbox with important fixes and new features. We’re overwhelmed by the community support and interest in this project, so this release also includes important fixes contributed by you. If you'd like to add new features to Devbox, we welcome Pull Requests. Want to request a new feature or report a bug? Submit an issue to the Devbox team.

Update to the Latest Version

Devbox automatically updates to the latest version each time you run a command.

You can confirm you’re running 0.0.4 by running:

devbox version

New in 0.0.4

This quick summary isn’t an exhaustive list of new content in this release, but highlights the major user-facing features in this release. For a full list of features, see the new commits since 0.0.3 was released just a week ago.

Path fix

Packages installed by Devbox now take priority over your local PATH

If your ~/.bashrc, ~/.zshrc or other shell startup script prefixed the path, this would overwrite the modifications Devbox made to the PATH. We now correctly add Nix packages at the beginning of the PATH after running your shell’s startup script. Thank you to @methyl, @TheGlenn88 and others for reporting this issue.

Stages

Stages are used to configure and run commands at different points of container creation. Devbox will automatically detect and configure the correct stage commands for your project based on your source code, but you can override any of these stages by configuring them in your devbox.json:

The install stage 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 stage runs after the install stage, and should be used to build or bundle your application.
The start stage will run when your container is started. This stage should include any commands needed to start and run your application.

For example, if you were running a Node.js project, you might configure the stages in your devbox.json like this:

   {
       "packages": [
           "nodejs"
       ],
       "install_stage": {
           "command": "npm install"
       },
       "build_stage":{
           "command":"npm run build"
       },
       "start_stage": {
           "command": "node ./dist/index.js"
       }
   }

See the Devbox Docs to learn more.

Devbox shell indicator

Once you launch devbox shell, a new indicator notes that you’re inside a Devbox shell. This will make it easier to quickly identify if you’re in a shell.

Devbox website

We’re excited to debut a brand-new website and docs pages for Devbox. If you’d like to dig deeper into Devbox than the ReadMe, you now have a great place to learn about Devbox. For example, to learn more about the CLI options on the docs pages.

Python + Poetry support

In addition to Go language detection, we now also auto-detect Poetry applications written in Python, and install the proper tools. The container image is based on a distroless image, making the resulting image small.

To get started with Python & Poetry:

Open a terminal in the source directory with your poetry.lock file
Initialize Devbox:
```
  devbox init
```
Start the shell:
```
  devbox shell
```

This also works with devbox build to build the container.

Anonymous Telemetry

The Devbox CLI now reports anonymous telemetry. This helps us better understand which features are used and lets us lean into the features you deem important. Users who prefer not to send telemetry can opt out by setting the DO_NOT_TRACK=1 environment variable. See this page for how we use this information.

Update today

We’re really excited about this new release of Devbox. Devbox automatically updates every time you run a command, so you may already have this version.

Need to install Devbox on a new machine? Install today:

curl -fsSL https://get.jetpack.io/devbox | bash

And let us know what you think on Discord and on Twitter. See an issue that didn’t make it into this release? Let us know in Github Issues or better yet, add the feature and create a Pull Request.

Devbox 📦 : Instant, easy, and predictable shells and containers

Rob Richardson — Thu, 01 Sep 2022 22:10:12 +0000

What is it?

Devbox is a command-line tool that lets you easily create isolated shells and containers. You start by defining the list of packages required by your development environment, and devbox uses that definition to create an isolated environment just for your application.

In practice, Devbox works similar to a package manager like yarn – except the packages it manages are at the operating-system level (the sort of thing you would normally install with brew or apt-get).

Devbox was originally developed by jetpack.io and is internally powered by nix.

Why we built it?

As a team, we wanted all of our engineers to have predictable development environments. Everyone should have the same tools, they should mirror production, and as a new engineer you should get that environment with a single command. At first, we created a docker container that reflected our development environment. But that brought other problems: the file system (and thus compilation) was really slow, and if you accidentally exited the container the build cache would get destroyed. We decided that developing inside a container was simply too slow. So we went looking for a solution that could work locally on our laptop. We decided to give nix a try. Nix solved a lot of the problems, it was promising! But its UX was more complex than necessary. It requires learning a new language in which you write nix expressions – which seemed hard to maintain.

And that's why we wrote Devbox. It's a wrapper around nix that makes the use-cases we care about really easy to use. If you know how to use yarn, you know how to use Devbox.

Demo

The example below creates a development environment with python 2.7 and go 1.18, even though those packages are not installed in the underlying machine:

Benefits

A consistent shell for everyone on the team

Declare the list of tools needed by your project via a devbox.json file and run devbox shell. Everyone working on the project gets a shell environment with the exact same version of those tools.

Try new tools without polluting your laptop

Development environments created by Devbox are isolated from everything else in your laptop. Is there a tool you want to try without making a mess? Add it to a Devbox shell, and remove it when you don't want it anymore – all while keeping your laptop pristine.

Don't sacrifice speed

Devbox can create isolated environments right on your laptop, without an extra-layer of virtualization slowing your file system or every command. When you're ready to ship, it'll turn it into an equivalent container – but not before.

Good-bye conflicting versions

Are you working on multiple projects, all of which need different versions of the same binary? Instead of attempting to install conflicting versions of the same binary on your laptop, create an isolated environment for each project, and use whatever version you want for each.

Instantly turn your application into a container

Devbox analyzes your source code and instantly turns it into an OCI-compliant image that can be deployed to any cloud. The image is optimized for speed, size, security and caching ... and without needing to write a Dockerfile. And unlike buildpacks, it does it quickly.

Stop declaring dependencies twice

Your application often needs the same set of dependencies when you are developing on your laptop, and when you're packaging it as a container ready to deploy to the cloud. Devbox's dev environments are isomorphic: meaning that we can turn them into both a local shell environment or a cloud-ready container, all without having to repeat yourself twice.

Installing Devbox

In addition to installing Devbox itself, you will need to install nix and docker since Devbox depends on them:

Install Nix Package Manager. (Don't worry, you don't need to learn Nix.)
Install Docker Engine or Docker Desktop. Note that docker is only needed if you want to create containers – the shell functionality works without it.
Install Devbox:

   curl -fsSL https://get.jetpack.io/devbox | bash

Quickstart: Fast, Deterministic Shell

In this quickstart we’ll create a development shell with specific tools installed. These tools will only be available when using this Devbox shell, ensuring we don’t pollute your machine.

Open a terminal in a new empty folder.
Initialize Devbox:

   devbox init

This creates a devbox.json file in the current directory. You should commit it to source control.

Add command-line tools from Nix Packages. For example, to add Python 3.10:

   devbox add python310

Your devbox.json file keeps track of the packages you've added, it should now look like this:

   {
      "packages": [
         "python310"
       ]
   }

Start a new shell that has these tools installed:

   devbox shell

You can tell you’re in a Devbox shell (and not your regular terminal) because the shell prompt and directory changed.

Use your favorite tools.

In this example we installed Python 3.10, so let’s use it.

   python --version

Your regular tools are also available including environment variables and config settings.

   git config --get user.name

To exit the Devbox shell and return to your regular shell:

   exit

Quickstart: Instant Docker Image

Devbox makes it easy to package your application into an OCI-compliant container image. Devbox analyzes your code, automatically identifies the right toolchain needed by your project, and builds it into a docker image.

Initialize your project with devbox init if you haven't already.
Build the image:

   devbox build

The resulting image is named devbox.

Tag the image with a more descriptive name:

   docker tag devbox my-image:v0.1

Auto-detected languages:

Devbox currently detects the following languages:

Want more languages? Ask for a new Language or contribute one via a Pull Request.

Additional commands

devbox help - see all commands

devbox plan - see the configuration and steps Devbox will use to generate a container

Join our Developer Community

Chat with us by joining the Jetpack.io Discord Server – we have a #devbox channel dedicated to this project.
File bug reports and feature requests using Github Issues
Follow us on Jetpack's Twitter for product updates

Deploy a C# & .NET Core Website to Kubernetes in 5 Minutes with Jetpack.io

Rob Richardson — Thu, 25 Aug 2022 21:59:00 +0000

Deploying to Kubernetes is Hard

Why Jetpack.io

In this tutorial, we'll build an ASP.NET Core website in C#, configure it for Jetpack.io, and deploy it to Kubernetes -- all in 5 minutes.

I. Building a C# and .NET App

In this example we'll quickly scaffold an ASP.NET Core MVC application. You could swap out these steps to use an existing ASP.NET Core web site, or scaffold a site using Razor Pages, Web API, or Minimal APIs.

Open Visual Studio
If the new project dialog doesn't open automatically, choose File -> New Project.
Choose ASP.NET (Model, View, Controller) and click next.

Choose a good name for this project, and save to a convenient directory.
In the Additional Information section, check Enable Docker then click Create.

You must have Docker Desktop installed for this function to work correctly.

Now we have a regular ASP.NET website. Feel free to customize this site to meet your needs.

II. Configure the App for Jetpack.io

Jetpack.io assumes your web server is running on port 8080, but the default project in ASP.NET runs on port 80. In this section we'll change the Dockerfile to run the web site on port 8080.

In the Solution Explorer, open Dockerfile.
Remove the 2 EXPOSE lines and add a new EXPOSE line:

   - EXPOSE 80
   - EXPOSE 443
   + EXPOSE 8080

Just under the EXPOSE line, add the environment variable telling ASP.NET Core to run on port 8080

   EXPOSE 8080
   ENV ASPNETCORE_URLS http://+:8080

The + tells ASP.NET to listen on all interfaces rather than just localhost.

Save and close the Dockerfile.
In Windows Explorer, move the Dockerfile from the project directory up 1 level to the Solution directory.

Jetpack.io assumes the Dockerfile is in your root directory.

III. Initialize the project with Jetpack.io

Jetpack.io needs some initial configuration to understand the ASP.NET web server. We need only do this once per website.

To install the Jetpack CLI, open a terminal and run

   curl https://get.jetpack.io -fsSL | bash

Jetpack CLI works on Linux, macOS, and on Windows via WSL2.

   jetpack auth login

Logging into Jetpack allows you to deploy to the Jetpack.io Kubernetes cluster. You can alsorun on your own cluster in your Azure, AWS, GCP, or private cloud account.

Initialize the project for Jetpack:

   jetpack init

This wizard interviews you and configures the Jetpack deployment strategy to match your application.

Answer that Yes, this is a web server. This tells Jetpack that we want to accept inbound traffic.

If we were building a scheduled cron job or a function that drained a queue, we could answer no.

Finish the wizard, and Jetpack CLI automatically generates an appropriate jetconfig.yaml file. You should commit this to source control.

IV. Deploy to Kubernetes using Jetpack.io

Now that the project is configured for Jetpack, deploying is really easy.

Open a terminal in the directory with the Dockerfile and jetconfig.yaml file.
Deploy to Kubernetes:

   jetpack dev

Now Jetpack makes the deployment really simple. Automatically it will:

Build the Docker image
Push the image to a private registry
Schedule the necessary Kubernetes resources
Create a publicly routable URL to test the website
Setup port-forwarding from your local machine
Stream application logs back to the terminal

Test the website:

In the console output will be the publicly routable URL. Click this URL to view the web page.

Jetpack also sets up port-forwarding, so you can also browse to http://localhost:8080/ to view the page.

Well that was easy

It's easy to deploy an ASP.NET app built with C# to Kubernetes with Jetpack.io. In this tutorial we scaffolded a website, configured it for Jetpack.io, and used Jetpack.io to deploy to Kubernetes. Jetpack.io is a great zero-DevOps solution for deploying to Kubernetes. Visit https://jetpack.io/docs/ to learn more and to start deploying your content to Kubernetes with ease.