How to Write a GitHub Action in Rust

[dbanty]

How to use a new cargo-generate template that I created to author GitHub actions using Rust! Check it out here.

---

This discussion was created from the release How to Write a GitHub Action in Rust.

[avsaase]

Hi, thanks so much for writing this blog post. Outside of the official documentation there is very little information about using docker containers for GitHub actions out there.

In your blog post you say:

You either need to publish a Docker image and pin your action to a specific tag or rebuild the Docker image every time that action runs. Rust can take a long time to compile, especially when waiting for Cargo to download dependencies—so building the image every time makes for a poor experience for the action's consumers.

Do you know if GitHub caches the docker image between workflow runs? If so, then letting the workflow rebuild the image from the Dockerfile instead of publishing the image to a registry might actually not be so bad, and it would simplify the development workflow.

[avsaase]

I found another way to do it. Instead of using the built-in docker based action I created a composite action that runs the required docker commands. This then allows you to use this action for the layer caching. Fetching and updating the cached layers also takes some time so the time savings are probably not as good as pre-compiling the binary and just running that. The benefit of this approach though is that everything is contained in the Rust code and the action.yaml file so it's more transparent and the end-user doesn't have to trust a pre-compiled binary.

Here's my example action: https://github.com/avsaase/rust-gh-action

[avsaase]

I got a bit nerd-sniped by writing GitHbu Actions in Rust and ended up writing some macros that makes it easier to return values back to the runner. It just created the first release: https://crates.io/crates/gha_main.

One thing I couldn't get working is letting the action fail when an error occurs. In your blog post you mention you can do that by calling std::process:exit(1) but it doesn't seem to do anything (except kill the tests in my ./tests/ folder because it stops the test executable). In the error integration tests for your graphql-check-action the workflow step also doesn't indicate an error by showing a red cross. I tried setting continue-on-error: false and the next step runs normally so the error status is not correctly communicated to the runner.

[dbanty]

I just double-checked and it definitely causes the step to fail—see this PR where I set continue-on-error: false. You're right that you wouldn't want to do that when running cargo test because it would kill the process, only integration tests. And with integration tests you don't want them to fail (❌) because the failure is actually the success case... when you're testing that it fails as intended... confusing.

Unfortunately, I didn't find a good way to verify that a step fails, which is why I use outputs to check the result.

[avsaase]

Hmm, for some reason this doesn't work for my action that uses the built-in container method, but it does for the composite action approach I described above.

I found yet another way to run actions written in rust and this one is actually much easier and faster. Instead of using docker to build and run the executable we do all that in the action itself. We can cache the compiled executable with a cache key generated from the hashed source and manifest files so it only needs to be compiled once (if you need to version your action you could use that as a cache key). Any rust binary is going to be much smaller than all those docker layers I was mucking around with earlier so fetching it from the cache is super fast. Obviously the first time the action is run from a given repository the code needs to be compiled. Using a pre-compiled binary or a published docker image still has an edge there.

Here's my action.yml if you're interested: https://github.com/avsaase/gha_main/blob/master/example-actions/direct/action.yml.

[dbanty]

You inspired me, so I made my own version of a Rust-based action which does not require Docker, works with private repos, and only needs you to build the binary once per version (using GitHub releases). Basically, it's like yours but using release artifacts instead of cache so it doesn't need to rebuild per-consumer. I haven't updated the template yet, but check out https://github.com/dbanty/sample-rust-action and tell me what you think!

The action.yml is pretty complicated, mostly because I wanted it to support all the major runners, so there's one artifact for each of Linux, macOS, and Windows.