Rust en Go: Twee systeemtalen voor containers en netwerken

De oorsprong van Rust ligt bij Mozilla. Het project startte in 2006 als persoonlijk initiatief van Graydon Hoare, softwareontwikkelaar en language engineer binnen Mozilla Research. Hoare ontwikkelde de taal met als doel een betere basis voor veilige en efficiënte systemensoftware. De naam "Rust" is de officiële benaming van de programmeertaal, niet een metaforische verwijzing.

Mozilla sponsorde het project officieel vanaf 2009. Dit gaf Rust toegang tot meer middelen en een breder ontwikkelteam binnen Mozilla Research. Het project kreeg steeds meer zichtbaarheid in de open-sourcegemeenschap.

Op 10 juli 2010 kondigde Mozilla Research Rust publiekelijk aan. Dit markeerde het begin van bredere adoptie en bijdragen van externe ontwikkelaars. De eerste publieke release, Rust 0.1, verscheen op 20 januari 2012. Deze vroege versie gaf ontwikkelaars toegang tot de kernprincipes van de taal: ownership, borrowing en lifetimes — concepten die centraal staan in Rusts unieke aanpak van geheugenbeheer.

Rust 1.0 verscheen op 15 mei 2015. Deze eerste stabiele versie maakte de taal geschikt voor productiegebruik, met een stabiele API en een voorspelbare releasecyclus.

In februari 2021 nam de Rust Foundation het governance- en sponsorschap over van Mozilla. De foundation, ondersteund door AWS, Microsoft, Google en Huawei, zorgt voor langdurige ondersteuning en verdere ontwikkeling van de taal en haar ecosysteem.

Go: eenvoud en schaalbaarheid bij Google

Go — ook bekend als Golang — is ontwikkeld bij Google door Robert Griesemer, Rob Pike en Ken Thompson. Thompson is mede-ontwerper van Unix en de C-taal. Go werd voor het eerst publiek aangekondigd op 10 november 2009. De eerste stabiele versie, Go 1.0, verscheen op 28 maart 2012.

Go is ontworpen om complexe software te vereenvoudigen, vooral in grote codebases binnen Google. De taal streeft naar duidelijkheid, snelle compilatie en eenvoudige concurrency via goroutines en channels.

Go kiest voor een minimalistische aanpak. Er zijn geen klassen, geen overerving, en het typesysteem is sober. Toch is Go geschikt voor netwerkdiensten, microservices en CLI-tools. Docker, Kubernetes en Prometheus zijn allemaal in Go geschreven.

Go's garbage collector en snelle compilatie maken de taal ideaal voor ontwikkeling in grote teams en continue integratie. De taal is ontworpen met multi-core processors en netwerkprogrammering in gedachten.

Toepassing in containers en infrastructuur

Go domineert in containerisatie en cloud-native tools. Docker, Kubernetes, Helm en etcd — kritieke onderdelen van de moderne DevOps-stack — zijn geschreven in Go. De taal produceert statisch gelinkte binaries die eenvoudig te deployen zijn.

Rust groeit in domeinen waar geheugenveiligheid en maximale prestaties cruciaal zijn: besturingssysteemlagen, embedded systems, veiligheidskritische netwerkcomponenten en high-performance databases. Rust wordt steeds vaker gebruikt voor low-level netwerkprotocollen, drivers en secure runtimes. Omdat Rust geen garbage collector heeft en geen runtime overhead kent, is de taal geschikt voor real-time systemen.

Rust in Docker: multi-stage builds

Rust-applicaties worden vaak gebouwd via multi-stage builds in Docker. Een traditionele build neemt alle lagen op — inclusief buildtools en tijdelijke dependencies — in de uiteindelijke container. Dit leidt tot zware en onveilige images. Met multi-stage builds vindt de compilatiestap plaats in een aparte stage. Alleen de gecompileerde binary wordt gekopieerd naar een lichte runtime-container.

Een voorbeeld van een multi-stage build voor een Rust-applicatie:

<h2>Stage 1: build</h2>
FROM rust:1.75 AS builder
WORKDIR /app
COPY Cargo.toml Cargo.lock ./
RUN cargo build --release
<h2>Stage 2: runtime</h2>
FROM debian:bookworm-slim
COPY --from=builder /app/target/release/myapp /usr/local/bin/
CMD ["myapp"]

Dit resulteert in kleine, veilige en efficiënte Docker-images. De buildcache speelt een belangrijke rol bij het versnellen van Rust-builds. Omdat Rust-compilatie bekend staat om langere buildtijden, is het belangrijk om de volgorde van instructies in het Dockerfile slim te kiezen. Door dependencies eerst te installeren en alleen code opnieuw te bouwen bij wijzigingen, verkorten ontwikkelaars de buildtijd aanzienlijk.

Docker SDK's en API

Docker ondersteunt zowel de Go- als de Rust-toolchain via zijn SDK's en API. De Docker Engine API is een RESTful interface om Docker-daemons programmatisch aan te sturen. Officiële SDK's zijn beschikbaar voor Go en Python. De Go SDK is bijzonder populair, gezien de taal zelf nauw verbonden is met Docker en Kubernetes.

Een voorbeeld van het gebruik van de Go SDK voor Docker:

package main</p><p>import (
    "context"
    "fmt"
    "github.com/docker/docker/client"
)</p><p>func main() {
    cli, err := client.NewClientWithOpts(client.FromEnv)
    if err != nil {
        panic(err)
    }
    cli.NegotiateAPIVersion(context.Background())
    fmt.Println("Docker client verbonden met API versie:", cli.ClientVersion())
}

Rust in CI/CD met GitHub Actions

Rust-applicaties kunnen automatisch worden gebouwd en getest met GitHub Actions. Een typische workflow omvat het aanmaken van een repository, het definiëren van een GitHub Actions workflow en het pushen van de gecompileerde Docker-image naar Docker Hub.

Een voorbeeld van een GitHub Actions workflow voor Rust:

name: Rust CI</p><p>on:
  push:
    branches: [ main ]</p><p>jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Install Rust
      uses: dtolnay/rust-toolchain@stable
    - name: Build
      run: cargo build --release
    - name: Test
      run: cargo test

Docker-builds en exporters kunnen de output van `docker build` niet alleen als image opslaan, maar ook als bestanden op schijf schrijven. Dit is handig voor distributie zonder containerisatie.

Verificatie

Controleer of Rust correct is geïnstalleerd:

rustc --version

Controleer of Go correct is geïnstalleerd:

go version

Controleer of Docker correct werkt:

docker run --rm hello-world

Veelgestelde problemen

Probleem: Rust-compilatie duurt te lang in Docker Oplossing: Gebruik build caching door dependencies eerst te installeren en code pas daarna te kopiëren. Zet de volgorde van instructies in het Dockerfile zo dat de cache optimaal wordt benut.

Probleem: Docker-image is te groot Oplossing: Gebruik multi-stage builds. Compileer in een build-stage en kopieer alleen de binary naar een lichte runtime-container.

Probleem: Go SDK geeft API-version mismatch Oplossing: Roep `cli.NegotiateAPIVersion(context.Background())` aan na het maken van de client. Dit stemt de API-versie af op de Docker-daemon.

Twee talen, één doel

Rust en Go zijn beide ontstaan uit praktische behoeften binnen grote technologiebedrijven. Rust, ontwikkeld binnen Mozilla Research door Graydon Hoare, richt zich op veiligheid en prestaties zonder compromissen. Go, ontwikkeld bij Google door ervaren programmeertalenten, kiest voor eenvoud, snelheid en schaalbaarheid.

Waar Go snelheid en eenvoud biedt, levert Rust veiligheid en controle. De geschiedenis van beide talen speelde zich af binnen verschillende organisaties — Mozilla en Google. Vandaag zijn ze gemeenschappelijk eigendom van een wereldwijde open-sourcegemeenschap, gesteund door fundaties en bedrijven die inzetten op duurzame, veilige en schaalbare software. Welke taal u kiest hangt af van de eisen van uw specifieke infrastructuur — en die keuze bepaalt mede hoe uw volgende systeemcomponent zich zal gedragen onder productielast.