How to Create a Ubuntu Packer Image and Deploy on a Bare Metal Server

Want to create a minimal Ubuntu image and deploy it on a bare-metal server? This guide shows you how to leverage Packer for automated image creation and Tinkerbell for streamlined deployment.?

Packer simplifies image management, making it easy to maintain and update systems, while Tinkerbell enables efficient bare-metal provisioning on standard hardware.?

This article is ideal for DevOps engineers and infrastructure teams seeking effective OS provisioning solutions. Combining these tools will enhance your infrastructure's flexibility and scalability.?

Let's dive in and explore how to achieve seamless deployment with Packer and Tinkerbell.

Understanding the Core Tools: Packer and Tinkerbell

Before starting, let's get familiar with Packer and Tinkerbell. These tools simplify creating and deploying images on bare-metal servers.

What is Packer?

Packer, developed by HashiCorp, is an open-source tool for building machine images across platforms. It doesn’t replace tools like Ansible but complements them.

Unique Advantages of Packer:

• Automated Image Creation: Simplifies building, saving time and reducing errors.
• Parallel Builds: Creates images for multiple platforms at once.
• Environment Consistency: Ensures uniformity from development to production.

What is Tinkerbell?

Tinkerbell is a provisioning engine for bare-metal servers, using microservices to manage OS and workload deployments.

Why Choose Tinkerbell:

• Network-Booting: Enables servers to boot via a network, removing manual tasks.
• Efficient Workflows: Automates steps, speeding up reliable deployments on bare-metal setups.

Setting Up the Packer Environment for Ubuntu Image Creation

With an understanding of Packer and Tinkerbell, the next step is to set up the environment needed to create a minimal Ubuntu image using Packer.

Installing and Configuring Packer

1. Download Packer:

• Visit the official Packer website.
• Download the latest version suitable for your operating system.

2. Install Packer:

• Follow the installation instructions specific to your OS.
• For example, you might use a package manager on Ubuntu or extract a binary to /usr/local/bin.

3. Verify the Installation:

• Open a terminal.
• Run packer --version to ensure it's installed correctly.

Directory Structure for Packer Image Build

Organizing your files properly is crucial for a smooth build process.

1. Create the Main Directory:

• Make a new directory named ubuntu_packer_image.
• This will house all the files related to the image build.

2. Set Up Subdirectories and Files:

• Inside ubuntu_packer_image, create a subdirectory called http.
• Place your preseed.cfg file inside the http directory.
• Place your config.json file inside the ubuntu_packer_image directory.

Visual Layout of the Directory Structure:

ubuntu_packer_image/

├── http/

│ ? └── preseed.cfg

└── config.json

This structure ensures that Packer can locate all necessary files during the image creation.

Crafting the Packer Template and Configuration Files

To create an automated Ubuntu image with Packer, we must define two key files: the preseed file and the config.json file. These files guide Packer in automating the build and configuration.

Creating the Preseed File

The preseed file automates Ubuntu installation by presetting options usually configured manually.

• Purpose of Preseed File: Automates the operating system installation, reducing manual input.
• Key Parameters:

a) Language and Locale: Sets system language and regional settings.

b) Timezone: Defines the timezone, ensuring correct system time.

c) Disk Partitions: Configures automatic disk partitioning, like setting up LVM or standard partitioning.

d) Default Packages: Specifies essential software packages (e.g., OpenSSH, Docker Compose) to include.

Defining the Config File (config.json)

The config.json file is Packer's primary configuration file, detailing how to build the machine image.

• Key Configuration Elements:

a) boot_command: Defines initial boot commands to automate startup and access the preseed file.

b) disk_size: Sets the disk size for the image, ensuring sufficient storage.

c) iso_urls: Lists URLs for downloading the Ubuntu ISO, if not already downloaded.

d) SSH Settings: Configures SSH credentials for remote access during setup, allowing automation and monitoring.

Building the Ubuntu Image with Packer

With your files configured, it's time to execute the Packer build and create the Ubuntu image.

Executing the Packer Build Command

• Command Syntax: Run PACKER_LOG=1 packer build config.json to start the build. The PACKER_LOG=1 part enables detailed logging.
• Understanding Output: The process outputs a VMDK image file in the output directory, while a compressed tar file is generated at the root directory.

Troubleshooting Common Build Issues

Errors may occur during the build process. Here's how to tackle them:

• Enable Logging: The PACKER_LOG flag helps identify issues by showing real-time logs.
• Common Issues:

a) Network Errors: Check network settings if the ISO download fails.

b) Incorrect File Paths: Verify paths for the config and preseed files.

c) Boot Issues: Revisit boot_command settings if the image doesn’t boot as expected.

Converting and Compressing the Image for Bare-Metal Deployment

After building the Ubuntu image, we must convert and compress it to prepare for bare-metal deployment.

Image Conversion with qemu-img

The qemu-img tool converts virtual disk formats, making it essential for preparing Packer images for bare-metal use.

• Why Use qemu-img: Converts the VMDK file to a raw format, making it compatible with Tinkerbell.
• Conversion Steps:

1. Install qemu-img (apt-get install -y qemu-utils).
2. Run qemu-img convert -f vmdk -o raw output-virtualbox-iso/packer-ubuntu-64-20.04-disk001.vmdk test_packer.raw.

Final Compression with gzip

Compressing the raw image makes network transfers faster and more efficient.

• Benefits of Compression: Reduces the file size for quicker network streaming during deployment.
• Resulting File Format: Produces test_packer.raw.gz, ready for deployment through Tinkerbell.

Deploying the Packer Image on Bare Metal with Tinkerbell

With the image ready, we’ll set up Tinkerbell to deploy it on bare-metal servers.

Tinkerbell Deployment Options

Tinkerbell offers multiple deployment options. Vagrant is ideal for our case as it simplifies the provisioning environment setup.

Setting Up the Provisioner

1. Launch the Provisioner: Set up Tinkerbell’s core services and run them as microservices.
2. Environment Preparation: Configure Vagrant to establish a local environment, making it easy to test deployments.

Defining Hardware Templates

A hardware template in Tinkerbell outlines the hardware settings required for the deployment.

• Template Structure:

1. ID: Unique identifier for tracking.
2. Metadata: Includes facility and server details.
3. Network: Configures network settings, IP addresses, and DHCP.
4. DHCP Configurations: Allows network booting and facilitates automated server setups.

Creating and Executing the Tinkerbell Workflow

It’s time to set up and run the Tinkerbell workflow to guide the deployment process on bare-metal servers.

Defining the Workflow Template

The workflow template outlines actions Tinkerbell will perform to deploy the OS.

• Template Sections:

1. Tasks: Groups related actions together, such as OS installation.
2. Actions: Defines specific commands within tasks to deploy the image.

• Example Actions:

1. image2disk: Streams the Ubuntu image to the server and writes it to the hard drive.
2. kexec: Boots the server into the new OS after installation.

Running the Workflow

1. Create Template: Use tink template create to upload the workflow template to Tinkerbell.
2. Launch Workflow: Execute tink workflow create to initiate the deployment process.
3. Verify Execution: Monitor Tinkerbell for workflow completion, ensuring each step succeeds.

Starting the Worker Node and Finalizing Deployment

With the workflow created, we’ll activate the worker node to complete the deployment process.

Worker Node Activation and Monitoring

1. Start the Worker Node: Run vagrant up worker to start the worker and initiate deployment.
2. Monitor Provisioning: Tinkerbell’s tink-worker container manages and executes workflow actions, ensuring tasks are complete as expected.

Reboot and System Check

1. Manual Reboot: Reboot the worker manually, if necessary, and select the correct boot partition.
2. System Verification: Confirm that the server boots into Ubuntu, validating a successful deployment on the bare-metal hardware.

Conclusion

This guide covered the complete process: creating a minimal Ubuntu image with Packer, converting it for bare-metal use, and deploying it through Tinkerbell. Packer automates image