Skip to content

Quick Start Guide

Quick Start Guide: Build your first AutoSD image

Goal: Build and run your first AutoSD image in 15 minutes.

This guide gets you from zero to a running AutoSD virtual machine with a simple, proven path. After you have succeeded in building an image, you can explore the more advanced features and customization options.

What you'll build

By the end of this guide, you will have the following:

  • A working AutoSD development environment
  • Your first custom AutoSD image built and running
  • An understanding of the basic development workflow
  • A foundation for more advanced customization
Prerequisites

=== "Linux" ```bash # Fedora/RHEL/CentOS Stream $ sudo dnf install -y git podman

# Ubuntu/Debian
$ sudo apt update && sudo apt install -y git podman
```

=== "macOS" ```bash # Install Homebrew if not already installed $ /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Install dependencies
$ brew install git podman
$ podman machine init
$ podman machine start
```
Step 1: Install Automotive Image Builder (2 minutes)

The fastest way to get started is using the containerized version.

  1. Create a working directory:

    bash $ mkdir -p ~/autosd-quickstart $ cd ~/autosd-quickstart

  2. Get the sample manifests:

    console $ git clone https://gitlab.com/CentOS/automotive/sample-images.git

  3. Download the containerized automotive-image-builder:

    console $ curl -o auto-image-builder.sh \ "https://gitlab.com/CentOS/automotive/src/automotive-image-builder/-/raw/main/auto-image-builder.sh"

  4. Make the auto-image-builder.sh script executable:

    console $ chmod +x auto-image-builder.sh

Alternative Installation Methods

For production use or if you prefer native installation, see Installing Automotive Image Builder.

Step 2: Build your first image (10 minutes)

Build a simple developer image that includes common tools:

$ sudo ./auto-image-builder.sh build \
  --target qemu \
  --export qcow2 \
  sample-images/images/simple-developer.aib.yml \
  my-first-autosd.qcow2

What's happening in the manifest

  • --target qemu: Build for QEMU virtual machine
  • --export qcow2: Export as QCOW2 format for virtualization
  • simple-developer.aib.yml: Use the pre-configured developer manifest
  • my-first-autosd.qcow2: Specify the output filename

Build Process

The build downloads packages, creates filesystem layouts, and generates your bootable image. First builds take longer due to downloads and caching.

Step 3: Run your image (1 minute)

  1. Download automotive-image-runner, a tool that you can use to quickly boot AutoSD images with QEMU:

    console $ curl -o automotive-image-runner \ "https://gitlab.com/CentOS/automotive/src/automotive-image-builder/-/raw/main/automotive-image-runner"

  2. Make the automotive-image-runner tool executable:

    console $ chmod +x automotive-image-runner

  3. Launch your new AutoSD image:

    console $ sudo ./automotive-image-runner my-first-autosd.qcow2

    Login credentials:

    • Username: root
    • Password: password
Step 4: Explore your AutoSD system (2 minutes)

After logging in, try these commands to understand what you've built:

# Check the OS version
cat /etc/os-release

# See all installed packages
rpm -qa

# See installed packages specific to automotive
rpm -qa | grep -E "automotive|rt|kernel" | head -10

# List all container images available locally
podman images

# Check running containers (should be none initially)
podman ps -a

# Check system kernel information
uname -a

# Display build-specific metadata
cat /etc/build-info

# View system partitions
lsblk

# Check systemd services
systemctl

Congratulations! You've successfully built and deployed your first AutoSD image.

What you've accomplished

You now have created the following:

  • A Working build environment: Automotive Image Builder installed and configured
  • A Custom AutoSD image: Built from a manifest with automotive-specific optimizations
  • A Runtime environment: A bootable VM running your custom OS
  • A Foundation for growth: Ready to explore advanced features
Next steps - choose your journey

Now that you have a working foundation, pick your path:

Customize your image

Learn to modify manifests and add your own applications:

Deploy to hardware

Move from virtual machines to real automotive hardware:

Implement safety features

Understand mixed criticality:

Get ready for production

Prepare for deployment and maintenance:

Understanding your build

The simple-developer.aib.yml manifest you used includes:

  • Base OS: CentOS Stream 9 with automotive kernel
  • Development tools: git, vim, development libraries
  • Container runtime: Podman for application deployment
  • Network tools: Standard networking and debugging utilities
  • Safety foundation: Basic mixed-criticality partition setup
Get help

This quick start guide is designed to get you productive quickly. For comprehensive understanding, explore the detailed documentation sections.