Ubuntu 20.04 Auto Installation With YAML In ISO Image

July 13, 2025 by StackCamp Team 54 views

Auto-Installing Ubuntu 20.04 with YAML Configuration in ISO Image

Automating the installation of operating systems is a crucial task for system administrators and developers, especially in environments where multiple machines need to be set up consistently. Ubuntu 20.04, a widely used Linux distribution, offers a powerful mechanism for automated installations using cloud-init. This system allows you to configure various aspects of the installation process, such as networking, user accounts, and package installations, through YAML configuration files. Integrating these configuration files into an ISO image enables a seamless and unattended installation experience. This article will guide you through the process of creating an ISO image with pre-configured YAML files for auto-installation on Ubuntu 20.04. This comprehensive guide ensures that readers can effectively automate their Ubuntu 20.04 installations, saving time and ensuring consistency across multiple systems. By embedding the configuration directly into the ISO, the setup process is streamlined, making it ideal for large-scale deployments or environments where manual configuration is impractical. The use of YAML for configuration provides a human-readable and easily editable format, which further simplifies the customization process. This approach not only reduces the potential for human error but also allows for quick replication of setups across different hardware, ensuring uniformity and reliability in your infrastructure. The following sections will detail the steps involved, from creating the necessary directories and YAML files to generating the bootable ISO image, providing a clear and concise pathway to automated Ubuntu 20.04 installations. Throughout this article, we'll emphasize best practices and provide practical examples to ensure that you can successfully implement these techniques in your own environment. The ability to automate system installations is a valuable skill for any IT professional, and this guide will equip you with the knowledge and tools needed to master this process on Ubuntu 20.04.

Before diving into the process, ensure you have the following prerequisites in place:

Ubuntu 20.04 System: You need an Ubuntu 20.04 system where you can create the ISO image. This can be a virtual machine or a physical server.
Root or Sudo Privileges: You need root or sudo privileges to install necessary tools and create directories.
Installed Tools: Ensure you have mkisofs (or genisoimage), xorriso, and cloud-init tools installed. You can install them using apt:
```
sudo apt update
sudo apt install genisoimage xorriso cloud-init
```
These tools are essential for manipulating ISO images and ensuring that the cloud-init configurations are correctly embedded. The genisoimage (or mkisofs) utility is used for creating the ISO image, while xorriso allows for more advanced modifications to the ISO, such as adding files and setting boot options. The cloud-init tool itself is necessary to test and validate your configurations before embedding them into the ISO. Having these tools readily available streamlines the process and minimizes potential roadblocks. Furthermore, understanding the purpose of each tool allows for greater flexibility and control over the ISO creation process. For instance, xorriso can be particularly useful for updating an existing ISO without needing to recreate it from scratch, saving considerable time and resources. Additionally, verifying that cloud-init is properly installed ensures that your system will correctly interpret and apply the configurations during the installation process. By taking the time to set up these prerequisites, you lay a solid foundation for a successful automated installation. Remember, the efficiency and reliability of your automated deployments depend heavily on the preparation and accuracy of the initial setup steps.
Basic Knowledge of YAML: Familiarity with YAML syntax is crucial for configuring the installation process.

The first step is to create a directory named cidata. This directory will contain the cloud-init configuration files that define the auto-installation settings. These files are critical for automating the installation process, as they instruct the system on how to configure itself without user intervention. The cidata directory acts as the central repository for these configuration files, ensuring they are organized and easily accessible when creating the ISO image. By creating this directory, you are essentially setting up the blueprint for your automated installation. This directory structure is a standard convention for cloud-init, and adhering to it ensures compatibility and proper functioning of the auto-installation process. The location of the cidata directory can be anywhere on your system, but it is best practice to keep it in a location where it can be easily managed and accessed. Throughout the subsequent steps, we will be adding specific configuration files to this directory, each playing a unique role in the overall automation strategy. The organization and content of the cidata directory directly influence the outcome of the installation, so careful planning and execution are essential. By starting with a well-structured cidata directory, you set the stage for a smooth and successful automated Ubuntu 20.04 installation.

Open your terminal and run the following commands:

mkdir cidata
cd cidata

This will create the cidata directory and navigate you into it.

The meta-data file is a crucial component in the cloud-init configuration, providing essential information about the instance being created. While it can be simple for local testing, it’s necessary for cloud environments. For a basic auto-installation, you can create a minimal meta-data file. This file typically contains metadata such as the instance ID, local hostname, and other identifying information that the system uses during initialization. Although its contents might seem minimal, the presence of a correctly formatted meta-data file is vital for cloud-init to function properly. It acts as a foundational element, allowing the system to recognize and process the user-data configurations. In the context of automated installations, the meta-data file ensures that the system is aware of its identity and can proceed with the configurations defined in the user-data file. Without it, the installation might fail to recognize the cloud-init configurations, leading to a manual installation process. Therefore, even for local testing, including a basic meta-data file is a best practice that ensures the robustness and reliability of your automated installation setup. The content of this file is typically concise, but its impact on the overall process is significant. As you progress with more complex deployments, you can expand the meta-data file to include more detailed information, but for a straightforward auto-installation, a minimal configuration is sufficient.

Create a file named meta-data using your favorite text editor (e.g., nano, vim).

nano meta-data

Add the following content:

instance-id: local
local-hostname: ubuntu-auto

Save and close the file.

instance-id: A unique identifier for the instance. For local testing, local is sufficient.
local-hostname: The hostname for the system.

The user-data file is the heart of the cloud-init configuration, containing the instructions for setting up the system during the first boot. This file allows you to automate a wide range of tasks, such as creating user accounts, configuring networking, installing packages, and running custom scripts. The YAML format of the user-data file makes it human-readable and easy to edit, enabling you to define complex configurations in a structured manner. By carefully crafting the user-data file, you can ensure that your Ubuntu 20.04 system is set up exactly as you need it, without any manual intervention. This level of automation is invaluable for large-scale deployments, where consistency and efficiency are paramount. The user-data file can include various sections, such as package installations, user creation, SSH key injection, and custom script execution, providing a comprehensive approach to system configuration. Each section is interpreted by cloud-init during the boot process, ensuring that the system is initialized according to your specifications. The flexibility of the user-data file allows you to tailor the installation to specific requirements, making it a powerful tool for system administrators and developers. By mastering the art of creating effective user-data files, you can streamline your deployment process and ensure a consistent and reliable setup across all your systems.

Create a file named user-data:

nano user-data

Add the following content to the user-data file. This example will:

Set the system hostname.
Create a new user with a specified password.
Install openssh-server.
Configure the network.

#cloud-config
hostname: ubuntu-auto
users:
  - name: auto_user
    passwd: "$6$rounds=4096$EXAMPLEsalt$EXAMPLEhashedPassword"
    sudo: ['ALL=(ALL:ALL) NOPASSWD:ALL']
    groups: sudo
    shell: /bin/bash

package_update: true
package_upgrade: true
packages:
  - openssh-server

network:
  version: 2
  ethernets:
    ens3:
      dhcp4: true
      dhcp6: false
  wifis:
    wlan0:
      dhcp4: true
      dhcp6: false
      access-points:
        "your_wifi_ssid":
          password: "your_wifi_password"

runcmd:
  - [ sh, -c, 'echo "Hello, Auto-Install!" > /tmp/auto_install.txt' ]

Replace "$6$rounds=4096$EXAMPLEsalt$EXAMPLEhashedPassword" with an actual hashed password. You can generate one using mkpasswd or an online tool. Also, replace `