Forem: Gaurav Gahlot

RustHours - Getting Started with Rust

Gaurav Gahlot — Thu, 26 Dec 2024 15:42:38 +0000

The very first live stream on Rust Hours. We started from zero to building a very small CLI application. The stream aims to help everyone learn Rust with a “follow along” approach.

Secure Your Kubernetes Applications with Self-Signed Certificates

Gaurav Gahlot — Sun, 29 Sep 2024 14:01:55 +0000

Introduction

Securing communication in microservices is a fundamental step to protect sensitive data and enforce privacy standards. Kubernetes supports several methods for securing applications. One such approach is to use SSL/TLS for encrypting traffic, and a cost-effective way to achieve this is by utilizing self-signed certificates.

In this blog post, I will walk you through the steps to secure your Kubernetes applications using self-signed certificates.

Let's get to it.

The Application

Our application is a basic HTTP server that serves a list of to-do items. Here’s the complete code with comments for clarity:

package main

import (
    "encoding/json" // Provides functions for encoding and decoding JSON data
    "log/slog"      // A package for structured logging
    "net/http"      // Provides HTTP client and server implementations
    "time"          // Provides functionality for measuring and displaying time

    "github.com/google/uuid" // Generates universally unique identifiers (UUIDs)
)

// The port on which the HTTP server will listen for incoming requests.
const port = ":80"

func main() {
    // Register the 'handleTodo' function to handle requests to the '/todo' path.
    http.HandleFunc("/todo", handleTodo)

    slog.Info("starting HTTP server", "port", port)

    // Starts the HTTP server on the specified port.
    err := http.ListenAndServe(port, nil)
    if err != nil {
        slog.Error("server failure", "error", err)
    }
}

// handleTodo handles the /todo URL path
func handleTodo(w http.ResponseWriter, _ *http.Request) {
    slog.Info("request received at path /todo")

    // Set the 'Content-Type' header and HTTP status code of the reponse.
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)

    // Get a list of to-do items.
    todoItems := getTodoList()

    // Encodes the list of to-do items as JSON and writes it to the HTTP response.
    err := json.NewEncoder(w).Encode(todoItems)
    if err != nil {
        slog.Error("failed to write response", "error", err)
    }
}

// getTodoList returns a list of to-do items
func getTodoList() []todoItem {
    return []todoItem{
        {
            DueDate: time.Now().AddDate(0, 0, 7),
            ID:      uuid.NewString(),
            Title:   "write a todo-app",
        },
        {
            DueDate: time.Now().AddDate(0, 0, 8),
            ID:      uuid.NewString(),
            Title:   "define K8s manifests",
        },
        {
            DueDate: time.Now().AddDate(0, 0, 9),
            ID:      uuid.NewString(),
            Title:   "use certificates",
        },
    }
}

// todoItem defines a to-do item
type todoItem struct {
    // Due date of the to-do item
    DueDate time.Time `json:"dueDate"`

    // A unique identifier for the to-do item
    ID      string    `json:"id"`

    // Title of the to-do item
    Title   string    `json:"title"`
}

The above program creates an HTTP server that responds to /todo requests with a predefined list of to-do items in JSON format. It uses UUIDs for unique identifiers and sets due dates in the future. The server logs important information and errors using the slog package.

Generate Self-Signed Certificate

As the next step, we need to create a self-signed certificate for our application. In order to do that, we will be using OpenSSL.

Following are the steps to generate the self-signed certificate using OpenSSL:

Generate an RSA private key

  openssl genrsa -out tls.key 4096

Generate a CSR (Certificate Signing Request) with the required CN and Subject Alternative Names (SANs). Use the openssl req command with the -subj and -addext options:

  openssl req -new -key tls.key -out tls.csr \
    -subj "/CN=todo-app" -addext \
    "subjectAltName=DNS:todo-app.default.svc.cluster.local,DNS:localhost,DNS:todo-app"

Generate the Self-Signed Certificate using the information from the CSR:

  openssl x509 -req -days 365 -in tls.csr -signkey tls.key \
    -out tls.crt -extensions req_ext \
    -extfile <(printf "[req_ext]\nsubjectAltName=DNS:todo-app.default.svc.cluster.local,DNS:localhost,DNS:todo-app")

(Optional) To view the content of the generated certificate in a human-readable form, you can use the openssl command-line tool to read the certificate and display its details.

  openssl x509 -in tls.crt -text -noout

Cluster Setup

We can leverage Kind’s extraPortMapping config option when creating a cluster to forward ports from the host to an ingress controller running on a node.

Create a kind cluster with extraPortMappings and node-labels.

extraPortMappings allow the local host to make requests to the Ingress controller over ports 80/443
node-labels only allow the ingress controller to run on a specific node(s) matching the label selector

# Three node cluster with an ingress-ready control-plane node
# and extra port mappings over 80/443 and 2 workers.

kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
  - role: control-plane
    kubeadmConfigPatches:
      - |
        kind: InitConfiguration
        nodeRegistration:
          kubeletExtraArgs:
            node-labels: "ingress-ready=true"
    extraPortMappings:
      - containerPort: 80
        hostPort: 80
        protocol: TCP
      - containerPort: 443
        hostPort: 443
        protocol: TCP
  - role: worker
  - role: worker

Check the cluster state:

➜ export KUBECONFIG=~/.kube/kind.yaml

➜ kubectl get nodes
NAME                 STATUS   ROLES           AGE     VERSION
kind-control-plane   Ready    control-plane   7d20h   v1.27.3
kind-worker          Ready    <none>          7d20h   v1.27.3
kind-worker2         Ready    <none>          7d20h   v1.27.3

Ingress NGINX

kubectl apply -f \
  https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/kind/deploy.yaml

The manifests contains kind specific patches to forward the hostPorts to the ingress controller, set taint tolerations and schedule it to the custom labelled node.

Now the Ingress is all setup. Wait until it's ready to process requests by running:

kubectl wait --namespace ingress-nginx \
  --for=condition=ready pod \
  --selector=app.kubernetes.io/component=controller \
  --timeout=90s

Deploying the Application

As the first step, let's create a namespace called todo, where will deploy our application and it's supporting resources.

kubectl create namespace todo

Next, we need to create a Kubernetes TLS Secret to store the self-signed certificate generated in a previous step.

kubectl create secret -n todo tls todo-app --cert tls.crt --key tls.key

Now, let's use the following YAML manifest to deploy our application:

kubectl apply -f - << EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: todo-app
  namespace: todo
spec:
  replicas: 2
  selector:
    matchLabels:
      app.kubernetes.io/name: todo-app
  template:
    metadata:
      labels:
        app.kubernetes.io/name: todo-app
    spec:
      containers:
        - name: todo-app
          image: todo-app:v0.1.0
          ports:
            - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: todo-app
  namespace: todo
spec:
  type: ClusterIP
  selector:
    app.kubernetes.io/name: todo-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: todo-app
  namespace: todo
spec:
  ingressClassName: nginx
  tls:
    - hosts:
        - "todo-app.default.svc.cluster.local"
        - "localhost"
        - "todo-app"
      secretName: todo-app
  rules:
    - http:
        paths:
          - pathType: Prefix
            path: "/todo"
            backend:
              service:
                name: todo-app
                port:
                  number: 80
EOF

This will create a deployment, a service, and an ingress resource for the todo-app.

Testing

We can use the curl utility to test if we can reach our server:

➜ curl --cacert tls.crt https://localhost/todo

  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0
curl: (60) SSL certificate problem: unable to get local issuer certificate
More details here: https://curl.se/docs/sslcerts.html

curl failed to verify the legitimacy of the server and therefore could not
establish a secure connection to it. To learn more about this situation and
how to fix it, please visit the web page mentioned above.

And, it seems that there is an issue with certificate verification.

Let's try to use curl with the -k option which allows to establish an insecure connection:

➜ curl -kv https://localhost/todo
*   Trying [::1]:443...
* Connected to localhost (::1) port 443
* ALPN: curl offers h2,http/1.1
* (304) (OUT), TLS handshake, Client hello (1):
* (304) (IN), TLS handshake, Server hello (2):
* (304) (IN), TLS handshake, Unknown (8):
* (304) (IN), TLS handshake, Certificate (11):
* (304) (IN), TLS handshake, CERT verify (15):
* (304) (IN), TLS handshake, Finished (20):
* (304) (OUT), TLS handshake, Finished (20):
* SSL connection using TLSv1.3 / AEAD-AES256-GCM-SHA384
* ALPN: server accepted h2
* Server certificate:
*  subject: O=Acme Co; CN=Kubernetes Ingress Controller Fake Certificate
*  start date: Sep 29 08:28:21 2024 GMT
*  expire date: Sep 29 08:28:21 2025 GMT
*  issuer: O=Acme Co; CN=Kubernetes Ingress Controller Fake Certificate
*  SSL certificate verify result: unable to get local issuer certificate (20), continuing anyway.
* using HTTP/2
* [HTTP/2] [1] OPENED stream for https://localhost/todo
* [HTTP/2] [1] [:method: GET]
* [HTTP/2] [1] [:scheme: https]
* [HTTP/2] [1] [:authority: localhost]
* [HTTP/2] [1] [:path: /todo]
* [HTTP/2] [1] [user-agent: curl/8.4.0]
* [HTTP/2] [1] [accept: */*]
> GET /todo HTTP/2
> Host: localhost
> User-Agent: curl/8.4.0
> Accept: */*
>
< HTTP/2 200
< date: Sun, 29 Sep 2024 09:16:45 GMT
< content-type: application/json
< content-length: 354
< strict-transport-security: max-age=31536000; includeSubDomains
<
[{"dueDate":"2024-10-06T09:16:45.708178138Z","id":"38afce86-0a6c-4b00-8d47-4dd0d836b89c","title":"write a todo-app"},{"dueDate":"2024-10-07T09:16:45.708189179Z","id":"4e42c873-b6cb-47b2-9d6b-0f476b59c332","title":"define K8s manifests"},{"dueDate":"2024-10-08T09:16:45.708191304Z","id":"dc8385d6-4c19-4605-b65d-3ad1ce2102fc","title":"use certificates"}]
* Connection #0 to host localhost left intact

If you look closely, you will notice that the server is using a fake certificate. This is why our previous request with --cacert option failed to verify.

Let's fix that by updating the default certificate used by the server.

Default SSL Certificate

The Ingress NGINX controller documentation states that:

For HTTPS, a certificate is naturally required. For this reason the Ingress
controller provides the flag --default-ssl-certificate. The secret referred to
by this flag contains the default certificate to be used when accessing the
catch-all server. If this flag is not provided NGINX will use a self-signed
certificate.

The complete documentation can be found here.

We can patch the NGINX Ingress controller deployment to use the certificate from todo/todo-app (namespace/secret-name) TLS secret as the default SSL certificate:

kubectl patch deployment \
  ingress-nginx-controller \
  --namespace "ingress-nginx" \
  --type='json' \
  -p='[{
    "op": "add",
    "path": "/spec/template/spec/containers/0/args/-",
    "value": "--default-ssl-certificate=todo/todo-app"
  }]'

Give it a few seconds so that the change is applied, and try again.

➜ curl -s --cacert tls.crt https://localhost/todo | jq .
[
  {
    "dueDate": "2024-10-06T09:25:40.344474844Z",
    "id": "f8b2d51d-f9d7-4468-a78b-f187e5fb7db7",
    "title": "write a todo-app"
  },
  {
    "dueDate": "2024-10-07T09:25:40.344487552Z",
    "id": "6506e497-208b-4a70-8181-2e6d3460738b",
    "title": "define K8s manifests"
  },
  {
    "dueDate": "2024-10-08T09:25:40.344489594Z",
    "id": "6a2c7af4-07e3-45f3-a04d-8aafcac2e4bc",
    "title": "use certificates"
  }
]

Congratulations!! 🥳

Conclusion

The post aimed to outline the steps to generate and deploy self-signed certificates using OpenSSL, configure Kubernetes secrets, and set up Ingress resources for SSL encryption. This gives you the foundational knowledge to enhance the security of your microservices and ensure encrypted communication.

Remember, as your applications grow and move closer to production, transitioning to certificates issued by trusted Certificate Authorities (CAs) would provide more security and reliability, especially for public-facing services.

If you find it helpful, stay tuned for more. Happy securing!

Running a Compiled Python Script from C# Applications

Gaurav Gahlot — Sun, 15 Sep 2024 13:02:18 +0000

Introduction

The interoperability between different programming languages enables developers
to leverage the best features of each language. One such powerful combination
is using Python and C# together.

I'm not a C# expert. This blogpost is purely based on my learning while I was
trying to run a Python script from a C# application.

Prerequisites

Python Installation: Ensure Python is installed on your machine and that the Python executable is accessible via the system's PATH. You can download Python from the official Python website.
C# Development Environment: You'll need an environment for writing and running C# code. Visual Studio is a popular choice, but you can use any editor or IDE of your choice.

A Python Script

In order to keep it simple, we will be using the following Python script:

def Greet(name):
    return f"Hello, {name}!"

Save the file as greeter.py to follow along.

Before running a Python script from C#, you would typically compile it into a
.pyc file. Here’s how you can compile your Python script:

Open a terminal or command prompt.
Run the following command:

python3 -m compileall greeter.py

This command will generate a directory named __pycache__ containing the
compiled .pyc file. In our case:

➜ tree .
.
├── __pycache__
│   └── greeter.cpython-312.pyc
└── greeter.py

C# Application

We start off by creating a console application using the dotnet CLI:

mkdir netpy && cd netpy
dotnet new console

Next, we add the pythonnet package to the project:

dotnet add package pythonnet

Update the Program.cs file with the code below to run the compiled (.pyc)
Python script (greeter.py):

using Python.Runtime;

// Specify the path to the Python shared library (DLL or .so file)
Runtime.PythonDLL = "/opt/homebrew/Cellar/python@3.12/3.12.4/Frameworks/Python.framework/Versions/3.12/lib/libpython3.12.dylib";

// Initialize the Python engine
PythonEngine.Initialize();

// Use a try-finally block to ensure proper cleanup
try
{
    // Acquire the GIL (Global Interpreter Lock)
    using (Py.GIL())
    {
        // Add path to __pycache__ directory
        dynamic sys = Py.Import("sys");
        sys.path.append("/Users/gaurav.gahlot/workspace/playground/netpy");

        // Import the compiled .pyc file
        dynamic greeter = Py.Import("greeter");

        // Call the Greet function
        string result = greeter.Greet("Alice");
        Console.WriteLine(result);
    }
}

finally
{
    // Necessary for proper serialization
    AppContext.SetSwitch("System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization", true);

    // Shutdown the Python runtime
    PythonEngine.Shutdown();
}

Detailed Explanation

Python.Runtime Initialization:
- You must set Runtime.PythonDLL property or PYTHONNET_PYDLL environment variable starting with version 3.0, otherwise you will receive BadPythonDllException upon calling Initialize.
- You can read more about the same in their documentation.
Initialize Python Engine:
- PythonEngine.Initialize(): This initializes the Python engine, making Python functionalities available within the C# environment.
Using Python with GIL:
- using (Py.GIL()): Ensures that the Global Interpreter Lock (GIL) is acquired, which is necessary for thread-safety when interacting with Python objects.
Modifying Python Path:
- dynamic sys = Py.Import("sys") and sys.path.append("path"): Adds the __pycache__ directory to the Python path. This is where the compiled .pyc file resides.
Import and Execute:
- dynamic greeter = Py.Import("greeter"): Imports the compiled Python script.
- string result = greeter.Greet("Alice"): Calls the Greet function from the imported script and prints the result.
Clean Up:
- AppContext.SetSwitch("System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization", true): Ensures proper serialization. You can learn more about it in this GitHub issue.
- PythonEngine.Shutdown(): Properly shuts down the Python engine to clean up resources.

Running the Application

Ensure that you have saved the code changes in Program.cs.
Open your terminal and navigate to the directory containing Program.cs
Run the application using dotnet run:

workspace/playground/netpy via .NET 8.0.401
➜ dotnet run
Hello, Alice!

This will execute the Python script and print the output to the console.

Conclusion

Using Python.NET simplifies the process of integrating Python with C#.
You can leverage the capabilities of Python directly from your C# applications,
making it possible to use Python's extensive libraries and simplicity alongside
C#'s strong performance and robust framework.

I hope this helps you get started with running compiled Python scripts
from C# applications smoothly.

Building a Rust Command-Line Utility - wc-rs

Gaurav Gahlot — Fri, 26 Jul 2024 06:39:58 +0000

Delving into Rust's capabilities, this post guides you through the process of crafting a command-line utility, wc-rs, mirroring the functionality of the classic wc tool with a modern twist.

Introduction

The motivation to build wc-rs comes from John Crickett's build your own wc tool coding challenge. Solving these challenges is a great way of learning different concepts, in my opinion. So, here we are starting with our first one.

The challenge is to build your own version of the Unix command line tool wc. The functional requirements for wc are concisely described by it’s man page - give it a go in your local terminal now:

man wc

The TL/DR version is: wc – word, line, character, and byte count.

So, let's get Rusty!!

Code Walkthrough

The wc-rs program is designed to be familiar to those who have used the original wc command, but under the hood, it leverages Rust's advanced features for improved performance and reliability.

The complete code is available at gauravgahlot/getting-rustywc-rs.

Dependencies

use clap::Parser;

We use the clap crate to simplify command-line argument parsing, making it effortless to define and handle the flags and options our program accepts.

The CLI Struct

#[derive(Parser)]
#[command(name = "wc-rs")]
#[command(version = "0.1.0")]
#[command(about="The wc-rs utility displays the count of lines, words, characters, and bytes contained in each input file", long_about=None)]
struct CLI {
    /// The number of bytes in each input file is written to the
    /// standard output. This will cancel out any prior usage of the
    /// -m option.
    #[arg(short = 'c')]
    bytes: bool,

    /// The number of lines in each input file is written to the
    /// standard output.
    #[arg(short)]
    lines: bool,

    /// The number of words in each input file is written to the
    /// standard output.
    #[arg(short)]
    words: bool,

    /// The number of characters in each input file is written to the
    /// standard output.
    #[arg(short = 'm')]
    chars: bool,
    files: Option<Vec<String>>,
}

Our CLI struct provides the skeleton for the command-line interface of wc-rs. With clap, beyond just defining the struct, we annotate it with information like the program's name, version, and a brief description.

Flags and Options

Each field in the CLI struct represents a command-line flag or option, complete with descriptive comments that clap uses to generate help messages:

-c for byte count
-l for line count
-w for word count
-m for character count

The files field holds an optional list of files to process. If it's empty, wc-rs reads from standard input.

The Output Struct

#[derive(Default)]
struct Output {
    bytes: u64,
    lines: u64,
    words: u64,
    chars: u64,
    file: Option<String>,
}

As we prepare to crunch numbers, we store our results in the Output struct. This is where the counts of bytes, lines, words, and characters will be accumulated, along with an optional filename for display purposes.

The Main Event

The main function is where we tie everything together. We parse the command-line arguments, iterate over files (or standard input), and calculate the statistics. We handle files and potential I/O errors gracefully, reflecting Rust's commitment to safe and explicit error management.

fn main() -> io::Result<()> {
    let cli = CLI::parse();
    let mut output: Vec<Output> = vec![];

    if let Some(files) = &cli.files {
        for file in files.iter() {
            let f = File::open(file)?;
            let reader = io::BufReader::new(f);

            let mut out = Output::new(file);
            out.bytes = fs::metadata(file)?.len();

            process_lines(reader, false, &mut out);
            output.push(out);
        }
    } else {
        let stdin = io::stdin();
        let reader = stdin.lock();
        let mut out = Output::default();

        process_lines(reader, true, &mut out);
        output.push(out);
    }

    print_output(&cli, output);

    Ok(())
}

Processing the Input

The process_lines function is at the heart of wc-rs. It takes a
reader—anything that implements the BufRead trait—and an Output struct by mutable reference, updating the counts as it iterates over the lines in the text.

fn process_lines<T: BufRead>(reader: T, from_stdin: bool, out: &mut Output) {
    for line in reader.lines() {
        match line {
            Ok(input) => {
                out.lines += 1;

                if from_stdin {
                    out.bytes += input.as_bytes().len() as u64;
                }

                let line_words: Vec<_> = input.split_terminator(" ").collect();
                out.words += line_words.len() as u64;

                line_words.iter().for_each(|w| out.chars += w.len() as u64);
            }
            Err(e) => eprintln!("{}", e),
        }
    }
}

We account for characters and bytes differently depending on whether we're reading from a file or from standard input to ensure accuracy. Word counts are obtained by splitting lines on spaces, highlighting Rust's iterator and collection capabilities.

Showing the Numbers

Finally, print_output is responsible for displaying the collected counts. Following the flags provided, it either prints specific stats or defaults to all counts if no flags are specified.

fn print_output(cli: &CLI, output: Vec<Output>) {
    let mut print_all = false;
    let mut total = Output::default();

    for out in &output {
        if !cli.lines && !cli.words && !cli.chars && !cli.bytes {
            print_all = true;
            if let Some(f) = &out.file {
                print!("\t{}\t{}\t{}\t{}\n", out.lines, out.words, out.bytes, f);
            } else {
                print!("\t{}\t{}\t{}\n", out.lines, out.words, out.bytes);
            }
        } else {
            if cli.lines {
                print!("\t{}", out.lines);
            }
            if cli.words {
                print!("\t{}", out.words);
            }
            if cli.bytes {
                print!("\t{}", out.bytes);
            } else if cli.chars {
                print!("\t{}", out.chars);
            }
            if let Some(f) = &out.file {
                print!("\t{}\n", f);
            } else {
                println!();
            }
        }

        total.lines += out.lines;
        total.words += out.words;
        total.bytes += out.bytes;
        total.chars += out.chars;
    }

    if output.len() > 1 {
        if print_all {
            print!("\t{}\t{}\t{}\t{}\n", total.lines, total.words, total.bytes, "total");
        } else {
            if cli.lines {
                print!("\t{}", total.lines);
            }
            if cli.words {
                print!("\t{}", total.words);
            }
            if cli.bytes {
                print!("\t{}", total.bytes);
            } else if cli.chars {
                print!("\t{}", total.chars);
            }

            println!("\ttotal");
        }
    }
}

Getting `wc-rs` Up and Running

To try out wc-rs, you'll compile and install it with cargo, Rust's build system and package manager. Once installed, running the program is just like using the traditional wc.

Installation

You can install the CLI using the below command:

cargo install --path .

Help

By using the --help option you can obtain the usage help for the CLI:

wc-rs --help
The wc-rs utility displays the count of lines, words, characters, and bytes contained in each input file

Usage: wc-rs [OPTIONS] [FILES]...

Arguments:
  [FILES]...

Options:
  -c             The number of bytes in each input file is written to the standard output. This will cancel out any prior usage of the -m option
  -l             The number of lines in each input file is written to the standard output
  -w             The number of words in each input file is written to the standard output
  -m             The number of characters in each input file is written to the standard output
  -h, --help     Print help
  -V, --version  Print version

Examples

Getting details of a single file:

wc-rs test.txt
        5       5       22      test.txt
      #lines  #words  #bytes

Getting details for multiple files:

wc-rs -wm test.txt Cargo.toml
        5       16      test.txt
        25      138     Cargo.toml
        30      154     total

Getting details for data from standard input

wc-rs
data from std input
        1       4       19

Display number of lines and characters only

wc-rs -lm test.txt
        5       16      test.txt

Conclusion

wc-rs might be a simple tool, but it embodies the elegance and robustness of Rust for command-line applications. Through an exploration of this utility, we’ve seen the power of meticulous error handling, the convenience of clap for argument parsing, and how straightforward it can be to work with files and strings in Rust.
Whether you're an experienced developer or new to the command line, wc-rs is a testament to Rust's capability to reinvent classic tools with a modern and reliable twist.

Raspberry Pi - Blinking an LED with Rust

Gaurav Gahlot — Fri, 01 Sep 2023 06:14:24 +0000

Prerequisites

Raspberry Pi (I am using Raspberry Pi 4 Model B)
LED (8mm, 3.5V, 30mA)
Resistor (220Ω)
Breadboard
Jumper wires (2 MF)

We assume that you have already installed Rust on your Raspberry Pi. If not, you can follow the instructions here.

GPIO Pins

GPIO stands for General Purpose Input/Output. Raspberry Pi has 40 GPIO pins. These pins are used to connect external devices to the Raspberry Pi. These pins can be used as either input or output pins. We will be using these pins to connect our LED to the Raspberry Pi.


Image Source - Raspberry Pi Documentation

The numbers in the above image are the Physical Pin Numbers. Also known as the Board Pin Numbers. The numbers in the image below are the BCM Pin Numbers. Also known as the GPIO Pin Numbers. These numbers are used in the code to refer to the GPIO pins.


Image Source - Raspberry Pi Documentation

The Circuit

The LED that I am using has the following specifications:

Forward Voltage: 3.5V
Forward Current: 30mA (0.03A)

One can tap into 3.3V or 5V power provided by the Raspberry Pi pins. Since, the LED requires 3.5V, we will be using the 5V pin. Also, we need a resistor to limit the current flowing through the LED. We can use the following formula to calculate the value of the resistor:

R = (V - Vf) / I

where,
R = Resistor value in Ohms
V = Voltage of the power source
Vf = Forward Voltage of the LED
I = Forward Current of the LED

The value of the resistor in Ohms will be:

R = (5 - 3.5) / 0.03
R = 50Ω

So, we need at least a 50 ohm resistor. I’ll choose 220 ohms. The higher the resistor value you use, the dimmer the LED.

Here is the circuit diagram we will be referring:


Circuit Diagram for LED

We will be using the BCM Pin 23 (Physical Pin 16) to power the circuit. The power flows through a 220Ω resistor and then through the LED. Note that the longer leg of the LED is connected to the resistor, while the shorter leg of the LED is connected to the ground pin 6 of the Raspberry Pi.

The Code

It's time to write the code that will make our LED blink. Create a new Rust project named led-blinking:

cargo new led-blinking

Add the following dependency to the Cargo.toml file:

[dependencies]
rppal = "0.14.1"

The rppal (Raspberry Pi Peripheral Access Library) crate provides access to the Raspberry Pi's GPIO, I2C, PWM, SPI and UART peripherals. You can read more about it here.

Now, update the src/main.rs file with the following code:

use std::thread;
use std::time::Duration;

use rppal::gpio::Gpio;
use rppal::system::DeviceInfo;

// GPIO uses BCM pin numbering. BCM GPIO 23 is tied to physical pin 16.
const GPIO_LED: u8 = 23;

fn main() {
    println!("Blinking an LED on a {}.", DeviceInfo::new()?.model());

    let gpio = Gpio::new().unwrap();
    let mut pin = gpio.get(GPIO_LED).unwrap().into_output();

    loop {
        // Blink the LED by setting the pin's logic level high for a second.
        pin.set_high();
        thread::sleep(Duration::from_millis(1000));

        pin.set_low();
        thread::sleep(Duration::from_millis(1000));
    }
}

Let’s understand the code. First, we import the thread and time modules from the standard library. Then, we import the Gpio struct from the rppal::gpio module. The Gpio struct provides access to the GPIO pins. Then, we import the DeviceInfo struct from the rppal::system module. The DeviceInfo struct provides information about the Raspberry Pi device in use.

Next, we create a new instance of the Gpio struct. Then, we get the pin 23 using the get method. The get method returns a Result<OutputPin, Error>. We use the unwrap method to get the OutputPin struct. Then, we convert the OutputPin struct into an output pin using the into_output method.

Finally, we enter an infinite loop. In each iteration of the loop, we set the pin to high using the set_high method. Then, we sleep for a second using the sleep method. Then, we set the pin to low using the set_low method and sleep for a second again.

Build and Run

Now, let’s build the project with cargo build:

led-blinking on master [?] via 🦀 v1.55.0
➜ cargo build
   Compiling libc v0.2.101
   Compiling rppal v0.12.0
   Compiling led-blinking v0.1.0 (/home/gaurav/Projects/led-blinking)
    Finished dev [unoptimized + debuginfo] target(s) in 2.25s

Then, let’s run the project with cargo run:

led-blinking on master [?] via 🦀 v1.55.0
➜ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/led-blinking`

You should see the LED blinking. If you want to stop the program, press Ctrl + C.


Glowing LED

Conclusion

In this blog post, we learned how to blink an LED with Rust on Raspberry Pi. We also learned how to calculate the value of the resistor required to limit the current flowing through the LED. If you have any questions or suggestions, feel free to drop a comment. A few useful links are given below:

Thanks for reading, see you in the next one!

How to load dynamic libraries in Rust?

Gaurav Gahlot — Mon, 14 Aug 2023 06:54:18 +0000

What is Dynamic Library Loading?

Dynamic library loading, also known as dynamic loading or runtime dynamic linking, is a programming technique that allows a program to load external libraries (also known as dynamic link libraries or shared libraries) into memory and use their functionalities at runtime, rather than at compile time. These libraries contain compiled code that can be executed by the program, enabling modularization, code reuse, and flexibility.

Dynamic library loading is in contrast to static linking, where all the necessary code is included in the program's executable binary during the compilation process. With dynamic library loading, the program remains smaller in size, and libraries can be updated or replaced without requiring changes to the main program.

Dynamic Library Loading in Rust

Rust provides a safe and ergonomic interface for loading dynamic libraries at runtime. The libloading crate provides a cross-platform API for loading dynamic libraries and calling functions defined in those libraries. It also provides a safe wrapper around the dlopen and dlsym functions on Unix-like systems and the LoadLibrary and GetProcAddress functions on Windows.

The complete source code is available on GitHub.

Setup the workspace

Let's start by creating a new Rust project named lib-loading:

cargo new lib-loading

# remove the src directory as we will be creating a workspace

Now, update the Cargo.toml file to create a workspace and add two members to it:

[workspace]

members = [
    "hello-world",
    "executor",
]

Create a dynamic library

Let's now create a library named hello-world with the following Cargo.toml file:

cargo new hello-world --lib

[package]
name = "hello-world"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["dylib"]

Note the crate-type field in the [lib] section. This tells the compiler to build a dynamic library instead of the default static library. This output type will create *.so files on Linux, *.dylib files on macOS, and *.dll files on Windows.

You can read more about different crate-types in the Rust Reference.

Next, update the src/lib.rs file to define a function named execute that prints a message to the console:

#[no_mangle]
pub fn execute() {
    println!("Hello, world!")
}

Name mangling is a compiler technique that encodes function names with additional information like the function's parameters and return type. However, this makes it difficult to call functions from other languages or dynamically loaded libraries.

The no_mangle attribute turns off Rust's name mangling, so that it has a well defined symbol to link to. This allows us to call the function from the dynamically loaded library.

Create a binary crate

Next, let's create a binary crate named executor that will load the hello-world library and call the execute function defined in it.

cargo new executor

Add a dependency on the libloading crate to the Cargo.toml file:

[package]
name = "executor"
version = "0.1.0"
edition = "2021"

[dependencies]
libloading = "0.8"

Now, update the src/main.rs file to load the hello-world library and call the execute function:

use libloading::{Library, library_filename, Symbol};

fn main() {
    unsafe {
        // Load the "hello_world" library
        let lib = Library::new(library_filename("hello_world")).unwrap();

         // Get the function pointer
        let func: Symbol<fn()> = lib.get(b"execute").unwrap();

        func() // Call the function
    }
}

It's a good practice to use the library_filename function to get the platform-specific filename of the library. This function returns libhello_world.so on Linux, libhello_world.dylib on macOS, and hello_world.dll on Windows.

Build and run the project

First, let's build the project with cargo build:

lib-loading on master [?] via 🦀 v1.69.0
➜ cargo build --release
   Compiling cfg-if v1.0.0
   Compiling hello-world v0.1.0 (/Users/gaurav.gahlot/workspace/playground/lib-loading/hello-world)
   Compiling libloading v0.8.0
   Compiling executor v0.1.0 (/Users/gaurav.gahlot/workspace/playground/lib-loading/executor)
    Finished release [optimized] target(s) in 1.42s

Next, run the executor using cargo run:

lib-loading on master [?] via 🦀 v1.69.0 took 2s
➜ cargo run -p executor --release
    Finished release [optimized] target(s) in 0.02s
     Running `target/release/executor`

Hello, world!

Congratulations! You've successfully loaded a dynamic library and called a function defined in it.

When to use Dynamic Library Loading?

Dynamic library loading is useful in several scenarios where you want to achieve modularity, flexibility, and runtime extensibility in your applications. Here are some situations where dynamic library loading can be advantageous:

Plugin Systems: If you're building an application that supports plugins or extensions, dynamic library loading can allow you to load and unload these plugins at runtime without modifying or restarting the main application. This can be useful for applications like text editors, web browsers, or media players that support third-party plugins.
Modular Applications: When you're developing a large application, dynamic library loading can help you break down the functionality into smaller, manageable components. This can lead to faster development cycles, easier maintenance, and improved code organization.
Hot Reload: For certain types of applications like game development tools or graphical design software, dynamic library loading can enable hot reloading. This means you can modify parts of the application's code, compile them into a dynamic library, and load that library without restarting the entire application. This greatly speeds up development iterations.
Platform-Specific Implementations: If your application needs to interact with platform-specific features, dynamic library loading allows you to provide different implementations for different platforms. You can load the appropriate library based on the runtime environment, avoiding unnecessary code in the main application binary.
Versioning and Updates: When you want to provide updates or bug fixes to a specific part of your application, you can distribute and load only the updated dynamic library without needing users to update the entire application.
Resource Sharing: Dynamic libraries can be used to share resources like database connections, network sockets, or other system resources across multiple parts of your application. This can help optimize resource usage and improve performance.
Language Interoperability: If you need to interface with code written in other programming languages (e.g., C or C++), dynamic libraries provide a way to call functions written in those languages from your Rust code.
Security and Isolation: In some cases, you might want to isolate certain components of your application for security reasons. Dynamic libraries can help you encapsulate sensitive code, limiting its exposure to the main application.

Challenges of Dynamic Library Loading

Dynamic library loading also introduces complexity and potential challenges. Here are a few things to consider when using dynamic libraries:

Memory Management: You need to manage memory and resource allocation properly, ensuring that you release resources and unload libraries when they're no longer needed to avoid memory leaks.
Compatibility: Ensuring that dynamically loaded libraries are compatible with your application's version and other libraries can be challenging. Version mismatches can lead to crashes or unexpected behavior.
Unsafe Code: Working with dynamically loaded libraries often involves using the unsafe keyword due to the inherent risks associated with runtime operations that Rust's safety mechanisms cannot fully verify.
Debugging: Debugging issues in dynamically loaded libraries can be more challenging compared to monolithic applications.
Performance Overhead: There can be a slight performance overhead when using dynamic libraries compared to statically linking code directly into your application binary.

Conclusion

In summary, dynamic library loading is most beneficial when you need to create modular, flexible, and extensible applications, but it requires careful design, proper resource management, and an understanding of the potential trade-offs. Rust's safety mechanisms can help you avoid many of the pitfalls associated with dynamic library loading, but you still need to be aware of the risks and challenges involved.

Getting started with Rust on Raspberry Pi

Gaurav Gahlot — Fri, 30 Jun 2023 06:05:42 +0000

In this blog post, we will learn how to get started with Rust on Raspberry Pi.

Introduction

Rust is a modern programming language that is blazingly fast, memory-efficient, and type-safe.
It is a great language for systems programming, and it is used by companies like Mozilla, Dropbox, and Cloudflare.

Raspberry Pi is a low-cost, credit-card sized computer that plugs into a computer monitor or TV, and uses a standard keyboard and mouse.
It is a capable little device that enables people of all ages to explore computing, and to learn how to program in language of their choice.

Let's get started.

Prerequisites

In terms of hardware, you will need the following:

Raspberry Pi 4 (4GB RAM) (already setup with Raspberry Pi OS)
Keyboard and Mouse
Monitor or TV

If you haven't already setup your Raspberry Pi, you can follow the instructions in earlier post - Setup Raspberry Pi without an external monitor.
If you don't have a Raspberry Pi, you can still follow along using a virtual machine.

Let's ensure that our Raspberry Pi is up-to-date.

gaurav@RPi4:~ $ uname -a
Linux RPi4 6.1.21-v8+ #1642 SMP PREEMPT Mon Apr  3 17:24:16 BST 2023 aarch64 GNU/Linux

gaurav@RPi4:~ $ sudo apt update && sudo apt upgrade -y
[sudo] password for gaurav:
Hit:1 http://archive.raspberrypi.org/debian bullseye InRelease
Hit:2 http://raspbian.raspberrypi.org/raspbian bullseye InRelease
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
All packages are up to date.
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
Calculating upgrade... Done
The following package was automatically installed and is no longer required:
  libfuse2
Use 'sudo apt autoremove' to remove it.
0 upgraded, 0 newly installed, 0 to remove and 0 not upgraded.

Installing Rust

The Rust documentation suggests to use a script available for us to install Rust with Rustup and Cargo on Raspberry Pi.

gaurav@RPi4:~ $ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
info: downloading installer

Welcome to Rust!

This will download and install the official compiler for the Rust
programming language, and its package manager, Cargo.

Rustup metadata and toolchains will be installed into the Rustup
home directory, located at:

  /home/gaurav/.rustup

This can be modified with the RUSTUP_HOME environment variable.

The Cargo home directory is located at:

  /home/gaurav/.cargo

This can be modified with the CARGO_HOME environment variable.

The cargo, rustc, rustup and other commands will be added to
Cargo's bin directory, located at:

  /home/gaurav/.cargo/bin

This path will then be added to your PATH environment variable by
modifying the profile files located at:

  /home/gaurav/.profile
  /home/gaurav/.bashrc

You can uninstall at any time with rustup self uninstall and
these changes will be reverted.

Current installation options:


   default host triple: aarch64-unknown-linux-gnu
     default toolchain: stable (default)
               profile: default
  modify PATH variable: yes

1) Proceed with installation (default)
2) Customize installation
3) Cancel installation
>1

info: profile set to 'default'
info: default host triple is aarch64-unknown-linux-gnu
info: syncing channel updates for 'stable-aarch64-unknown-linux-gnu'
info: latest update on 2023-06-01, rust version 1.70.0 (90c541806 2023-05-31)
info: downloading component 'cargo'
  6.7 MiB /   6.7 MiB (100 %)   1.3 MiB/s in  4s ETA:  0s
info: downloading component 'clippy'
info: downloading component 'rust-docs'
 13.6 MiB /  13.6 MiB (100 %)   3.7 MiB/s in  4s ETA:  0s
info: downloading component 'rust-std'
 32.8 MiB /  32.8 MiB (100 %)   2.9 MiB/s in 11s ETA:  0s
info: downloading component 'rustc'
 75.5 MiB /  75.5 MiB (100 %)   3.4 MiB/s in 24s ETA:  0s
info: downloading component 'rustfmt'
info: installing component 'cargo'
info: installing component 'clippy'
info: installing component 'rust-docs'
 13.6 MiB /  13.6 MiB (100 %)   1.6 MiB/s in  7s ETA:  0s
info: installing component 'rust-std'
 32.8 MiB /  32.8 MiB (100 %)   5.8 MiB/s in  5s ETA:  0s
info: installing component 'rustc'
 75.5 MiB /  75.5 MiB (100 %)   6.3 MiB/s in 11s ETA:  0s
info: installing component 'rustfmt'
info: default toolchain set to 'stable-aarch64-unknown-linux-gnu'

  stable-aarch64-unknown-linux-gnu installed - rustc 1.70.0 (90c541806 2023-05-31)


Rust is installed now. Great!

To get started you may need to restart your current shell.
This would reload your PATH environment variable to include
Cargo's bin directory ($HOME/.cargo/bin).

To configure your current shell, run:
source "$HOME/.cargo/env"

Note that you will be prompted to choose an installation option. You can press the return key or enter 1 to continue with the defaults as I did. Of course, you can choose other options as needed.

Notice the information at the end of the command execution:

To get started you may need to restart your current shell.
This would reload your PATH environment variable to include
Cargo's bin directory ($HOME/.cargo/bin).

To configure your current shell, run:
source "$HOME/.cargo/env"

You may choose to restart, but I will source the env file to continue:

gaurav@RPi4:~ $ source "$HOME/.cargo/env"

Once done, we can check the version of the components installed:

gaurav@RPi4:~ $ rustup -V
rustup 1.26.0 (5af9b9484 2023-04-05)
info: This is the version for the rustup toolchain manager, not the rustc compiler.
info: The currently active `rustc` version is `rustc 1.70.0 (90c541806 2023-05-31)`

gaurav@RPi4:~ $ rustc -V
rustc 1.70.0 (90c541806 2023-05-31)

gaurav@RPi4:~ $ cargo -V
cargo 1.70.0 (ec8a8a0ca 2023-04-25)

Our First Program

I prefer to keep my projects in a directory workspace in my home directory:

mkdir ~/workspace
cd ~/workspace

Let's create a simple Rust program to print "Hello World!" to the console.

gaurav@RPi4:~/workspace $ cargo new --bin hello-world
     Created binary (application) `hello-world` package

gaurav@RPi4:~/workspace $ cd hello-world/
gaurav@RPi4:~/workspace/hello-world $ tree .
.
├── Cargo.toml
└── src
    └── main.rs

1 directory, 2 files

Also, take a look at the contents of the main.rs file:

gaurav@RPi4:~/workspace/hello-world $ cat src/main.rs
───────┬─────────────────────────────────────────────────────────────────────────────────
       │ File: src/main.rs
───────┼─────────────────────────────────────────────────────────────────────────────────
   1   │ fn main() {
   2   │     println!("Hello, world!");
   3   │ }
───────┴─────────────────────────────────────────────────────────────────────────────────

Now, let's run our program:

gaurav@RPi4:~/workspace/hello-world $ cargo run
   Compiling hello-world v0.1.0 (/home/gaurav/workspace/hello-world)
    Finished dev [unoptimized + debuginfo] target(s) in 1.33s
     Running `target/debug/hello-world`
Hello, world!

Congratulations! You have successfully run your first Rust program on the Raspberry Pi. 🥳

Conclusion

In this article, we learned how to install Rust on the Raspberry Pi. We also created a simple Rust program and ran it on the Raspberry Pi.
In the next article in this series, we will learn how to setup a sophisticated Rust development environment on the Raspberry Pi.
So, stay tuned!

Setup your Raspberry Pi 4 - without an external monitor

Gaurav Gahlot — Mon, 20 Dec 2021 14:37:33 +0000

I received my first Raspberry Pi yesterday. I have got a Raspberry Pi 4 Model B with 8GB RAM. As I was doing the setup, I found it difficult to get all the information in one place, so I decided to write this blog post.

This post documents the steps to setup a brand new Raspberry Pi without an external monitor.

Here is what we are going to do:

install the Raspberry Pi OS (64-bit)
setup internet connection over WiFi
SSH and run updates
setup VNC Viewer
install Docker

We have quite a lot to cover, so let's get started.

Prerequisites

Following are some prerequisites for the setup:

Raspberry Pi board (obviously)
connector for power supply
microSD card (depends on your Pi model though) and a card reader
another system to do the work (on the same network)
SSID (network name)
PSK (network password)

Installing Raspberry Pi OS

The very first thing you need for the setup is the Raspberry Pi Imager. Raspberry Pi Imager is the quick and easy way to install Raspberry Pi OS and other operating systems to a microSD card, ready to use with your Raspberry Pi. The imager provides a wide range of stable operating systems. However, they are all 32-bit (I think). You can very well choose either one and move forward.

Since the Raspberry Pi 4 supports 64-bit OS, I will be installing the 64-bit Raspberry Pi OS. You can download the same from here. Please note that it's still in beta testing and a list of known issues can be found on the same forum.

Follow the steps below to install the OS:

Connect your microSD card to the system where you have downloaded the OS and imager.
In the imager select the Choose OS option.
Scroll down the pop-up list and select Use custom at the end.
Select the downloaded OS (.zip file)
Now select Choose Storage and select the connected SD card.
Click Write and wait for the process to complete.

Note: If you choose an OS from the recommended list, it will first download the OS and then write it to the SD card. This will take a little longer, so be patient.

Setup Wifi

Now that we have installed the OS, it's time to setup the network.

Open the SD card in a file manager of your choosing. If you are using a Windows based system, the SD card will directly land you in the boot directory. You can double check it by looking for these files:



bootcode.bin
loader.bin
start.elf
kernel.img
cmdline.txt

Create a file named wpa_supplicant.conf next to the above files, i.e., in the boot directory.

However, if you are on a Linux based system you need to create the file as /etc/wpa_supplicant/wpa_supplicant.conf. Now, add the following content to your file:



country=us
update_config=1
ctrl_interface=/var/run/wpa_supplicant

network={
  scan_ssid=1
  ssid="network_SSID_here"
  psk="network_password_here"
}

Save the file and ensure that the file extension is .conf.
Insert the SD in the slot of the Pi board, connect the power and turn it on. As the Pi boots you should see the blinking green and red lights. Once the boot is complete the green light will turn off.

SSH and Run Updates

Now, it's time to find the IP address of your Raspberry Pi. There are multiple ways to scan a network and get connected devices. In order to make it easy you can use an IP Scanner. This article provides a good list of scanners that you can choose from. Select and install one.

Scan your network and you should see a Raspberry Pi device connected. Here is an example:

Note the IP address. Let's SSH into the Pi with default credentials.



# username - pi
# password - raspberry

➜ ssh pi@192.168.0.232
pi@192.168.0.232's password:
Linux raspberrypi 5.10.63-v8+ #1488 SMP PREEMPT Thu Nov 18 16:16:16 GMT 2021 aarch64

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
Last login: Sun Dec  4 00:43:28 2021 from 192.168.0.233
pi@raspberrypi:~ $

Here are a few things you should do as you login:



# change the password
$ passwd

# get updates
$ sudo apt update

# upgrade the system
$ sudo apt upgrade

The Raspberry Pi OS also provides a configuration manager that you can start using the sudo raspi-config command. It will prompt you with the following or similar term-UI:



Raspberry Pi 4 Model B Rev 1.4


┌────────────────────────┤ Raspberry Pi Software Configuration Tool (raspi-config) ├─────────────────────────┐
│                                                                                                            │
│                      1 System Options       Configure system settings                                      │
│                      2 Display Options      Configure display settings                                     │
│                      3 Interface Options    Configure connections to peripherals                           │
│                      4 Performance Options  Configure performance settings                                 │
│                      5 Localisation Options Configure language and regional settings                       │
│                      6 Advanced Options     Configure advanced settings                                    │
│                      8 Update               Update this tool to the latest version                         │
│                      9 About raspi-config   Information about this configuration tool                      │
│                                                                                                            │
│                                                                                                            │
│                                                                                                            │
│                               <Select>                               <Finish>                              │
│                                                                                                            │
└────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

Setup VNC Viewer

Honestly, you don't really need a GUI to work with a Raspberry Pi. But it can be useful at times, especially if you are a beginner. Let's setup VNC viewer just for that.

On your Pi, install the realvnc server:



sudo apt install realvnc-vnc-server

Start the VNC server using the vncserver command:



vncserver

...

Running applications in /etc/vnc/xstartup

VNC Server catchphrase: "Needle baker salute. Price diagram origin."
             signature: e4-20-40-65-48-3d-f7-51

Log file is /home/pi/.vnc/raspberrypi:1.log
New desktop is raspberrypi:1 (192.168.0.232:1)

Notice the last line that provides details about how you can connect to the desktop started by the server.

Now install the VNC Viewer (also know as VNC client) on the system you want to have the display on. Once installed, start the client and use the desktop address you got from the VNC server (192.168.0.232:1 in my case). When prompted, provide the Raspberry Pi user credentials you used to SSH into the Pi.

Note: With this setup, each time you want to access the GUI you will need to SSH and start the server manually. You can enable the VNC interface by default from the configuration manager (raspi-config) -> Interface Options -> VNC -> Enabled setting.

Congratulations! You have successfully setup your Raspberry Pi. :)

Install Docker

Installing Docker on Raspberry Pi 4 is super simple. All you need is to run the following command that gets a script and pipes it to the shell:



curl -sSL https://get.docker.com/ | sh

By default, Docker daemon runs a privileged service and a non-privileged user can't connect with it without using sudo. Meaning, if you try executing docker ps command you would get the following error message:



$ docker ps
Got permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock: Get "http://%2Fvar%2Frun%2Fdocker.sock/v1.24/containers/json": dial unix /var/run/docker.sock: connect: permission denied

In order fix this we need to add the pi user to the docker group. Once done, reboot the Pi.



sudo usermod -aG docker $USER
sudo reboot

SSH again and try executing the docker ps command w/o sudo and you should not get any errors.



$ docker ps

CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES

Conclusion

In this blog post, we have setup a Raspberry Pi 4 Model B from scratch without an external monitor connected to the Pi. We have also installed Docker and so, the Pi is all set to get you rocking on a new journey. In the next post, we will setup Rust and write our first application. Later we will containerise the application and run it on the Raspberry Pi. So, stay tuned.

I hope you found the steps useful and I look forward to your valuable feedback. If you run into issue, please do let me know and I will be happy to help.

Forem: Gaurav Gahlot

RustHours - Getting Started with Rust

Secure Your Kubernetes Applications with Self-Signed Certificates

Introduction

The Application

Generate Self-Signed Certificate

Cluster Setup

Deploying the Application

Testing

Default SSL Certificate

Conclusion

Running a Compiled Python Script from C# Applications

Introduction

Prerequisites

A Python Script

C# Application

Detailed Explanation

Running the Application

Conclusion

Building a Rust Command-Line Utility - wc-rs

Introduction

Code Walkthrough

Dependencies

The CLI Struct

Flags and Options

The Output Struct

The Main Event

Processing the Input

Showing the Numbers

Getting wc-rs Up and Running

Installation

Help

Examples

Conclusion

Raspberry Pi - Blinking an LED with Rust

Prerequisites

GPIO Pins

The Circuit

The Code

Build and Run

Conclusion

How to load dynamic libraries in Rust?

What is Dynamic Library Loading?

Dynamic Library Loading in Rust

Setup the workspace

Create a dynamic library

Create a binary crate

Build and run the project

When to use Dynamic Library Loading?

Challenges of Dynamic Library Loading

Conclusion

Getting started with Rust on Raspberry Pi

Introduction

Prerequisites

Installing Rust

Our First Program

Conclusion

Setup your Raspberry Pi 4 - without an external monitor

Prerequisites

Installing Raspberry Pi OS

Setup Wifi

SSH and Run Updates

Setup VNC Viewer

Install Docker

Conclusion

Getting `wc-rs` Up and Running