Articles tagged #rust
Generating a docker image with nix
There it is. The final installment.
Over the course of this series, we’ve built a very useful Rust web service that shows us colored ASCII art cats, and we’ve packaged it with docker, and deployed it to https://fly.io.
We did all that without using nix at all, and then in the last few chapters,
we’ve learned to use nix, and now it’s time to tell docker build goodbye,
along with this whole-ass Dockerfile:
Doing geo-location and keeping analytics
I sold you on some additional functionality for catscii last chapter, and we
got caught up in private registry / docker shenanigans, so, now, let’s resume
web development as promised.
Adding geolocation
We kinda left the locat crate stubby, it doesn’t actually do any IP to
location lookups. It doesn’t even have a dependency on a crate that can do
that.
Using the Shipyard private crate registry with Docker
Wait wait wait, so we’re not talking about nix yet?
Well, no! The service we have is pretty simple, and I want to complicate things a bit, to show how things would work in both the Dockerfile and the nix scenario.
And because I don’t like contrived examples, we’re going to do something somewhat real-world: we’re going to geo-locate visitors, and track how many visits we get from each country.
Deploying catscii to fly.io
Disclaimer:
Because I used to work for fly.io, I still benefit from an employee discount at the time of this writing: I don’t have to pay for anything deployed there for now.
fly.io is still sponsoring me for developing hring, but this isn’t a sponsored post. It’s just a good fit for what we’re doing here, with a generous free tier.
In the previous chapter, we’ve written a Dockerfile to build the
catscii service inside Docker. The result is a container image that can be
pushed to production!
Writing a Dockerfile for catscii
Now that our service is production-ready, it’s time to deploy it somewhere.
There’s a lot of ways to approach this: what we are going to do, though, is build a docker image. Or, I should say, an OCI image.
This is still a series about Nix, but again: because the best way to see the benefits of Nix is to do it without Nix first, we’ll use only Docker’s tooling to build the image.
Serving ASCII cats over HTTP
Our catscii program does everything we want it to do, except that it’s a
command-line application rather than a web server. Let’s fix that.
Enter axum
The documentation for the axum crate tells us how to make a basic web server, and we honestly don’t need much more than that.
So let’s add axum:
amos@miles:~/catscii$ cargo add axum@0.6
Updating crates.io index
Adding axum =0.6 to dependencies.
Features:
+ form
+ http1
+ json
+ matched-path
+ original-uri
+ query
+ tokio
+ tower-log
- __private_docs
- headers
- http2
- macros
- multipart
- w
Printing ASCII cats to the terminal
Now that our development environment is all set up, let’s make something useful!
Creating the catscii crate
From a VS Code window connected to our VM (as we just set up), let’s make a new Rust project:
amos@miles:~$ cargo new catscii
Created binary (application) `catscii` package
And open it in a new VSCode window:
amos@miles:~$ code catscii
Even though we’re running this “code” command in the VM guest, VSCode set up enough plumbing that it communicates back to the host, telling it to open another VSCode window, connected to the same SSH remote, in the right folder.
Building a Rust service with Nix
Go back to the homepage.