We assume that the target board is already configured to be reachable at a given IP address or hostname over the same network as the development machine, and has SSH exposed. We also assume that SSH is configured with public key based authentication, so that no password is required every time we connect to it.
The simplest way is to manually create an empty folder with the desired name (e.g. media hello-world), CD into it, and run cargo unit --bin ; this creates all the necessary source files for an executable (binary) hello world application. To make things more interesting, we will build an HTTP server application, which keeps running indefinitely in the background.
We also add a print instruction so that we can easily tell whether and when the binary starts correctly, rather than having to stare at a blank terminal and guess. Since we will be iterating over our program, and each iteration involves at a minimum compiling on the development machine and running on the target board, it is useful to create a simple script with the necessary commands, so that we can just run it, and we don’t need to type the commands out every time.
We create a text file in the same directory, called deploy, with the following content (we will add more and more steps to it as we go): We then make the script executable with ch mod +x ./deploy, so that we can then just run it directly as ./deploy, which we can try immediately.
What would happen if we just tried to copy and run it on the target Raspberry Pi board? The TARGET_HOST variable specifies the username and host name (or IP address) of the target board, which must be reachable over the network from the development machine.
The last line connects to the target board over SSH and tries to run the binary we just copied there. Which indeed confirms to us that we need to do put more effort into this in order to end up with a binary that is compatible with the Raspberry Pi.
When we run this version of the deployment script, at this point most likely we get an error similar to following: In fact, if this is the first time we compile (or link) anything ARM -related, it is likely we do not yet even have any tools installed that can do the job, so we first need to procure them.
This instructs cargo to use the ARM -specific version of GCC for linking binaries compiled for the armv7-unknown-linux-gnueabihf Rust target. We now want to make this binary behave like a proper service, which means restarting it if it crashes, and also automatically starting it at boot time, without human intervention.
For this article we use system, which requires more configuration, but it is also much more solid and reliable than other alternatives. From the terminal, we then create a file called /lib/system/system/hello-world.service (we probably need to run our text editor as root via judo) on the target board.
If necessary (especially for more complex applications) can check the full logs for the service (even across restarts) with the following command: Let us try to see what system does in order to keep the service up and running, by simulating a crash via the judo kill all hello-world command we saw earlier.
If we do that, and then quickly (within the 10-second window we specified in the unit configuration) run judo system status hello-world.service again, we see the following output: Predictably, if we wait a few more seconds, system restarts the service, and the HTTP server is up again.
Let us try to make a change to the code and deploy a new version of the server, in a way that works nicely with system. What we actually want is to replace the previous binary, and ask system nicely to restart the service for us.
This script now compiles and copies the binary as before, but instead of running it interactively as the final step, it just restarts the service via the system restart command, which stops the previous instance and starts a new one, causing the new version of the binary to be executed. Rust is a systems programming language that runs amazingly fast, prevents segfaults, and guarantees thread safety.
Support for different platforms are organized into three tiers, each with a different set of guarantees. Platforms are identified by their “target triple” which is the string to inform the compiler what kind of output should be produced.
Std: indicates the full standard library is available. Indicates the standard library support is unknown or a work-in-progress.
Tier 1 platforms can be thought of as “guaranteed to work”. Official binary releases are provided for the platform.
Landing changes to the rust slang/ rust repository's master branch is gated on platforms building. For some platforms only the standard library is compiled, but for others rust and cargo are too.
Same goes for Raspberry Pi, the small but mighty computer, that costs just £30 but brings a whole awesomeness on board (I wish Broadcom Engineers were a bit more open with their design and less lazy to implement the whole ARM Gig; but let’s keep this for another time). Here is a small walkthrough, on how to use Mac OSX, Linux or even Windows (hey not tested, but I am sure you can make it work, the tools are the same) to compile your Rust marvellousness and run the binary directly on the Raspberry Pi (2/3/3+).
The simple steps for achieving all the above are the following (the first two steps assume Mac OSX; for Windows users you can do something similar but Google on how to install the tools described): Add the Vagrant box you want to use, start it and ssh into it.
Now you ‘re running a Debian, straight into your Mac OSX at the speed of light ) It’s a good idea to update to the current package versions.