This is a draft document that was built and uploaded automatically. It may document beta software and be incomplete or even incorrect. Use this document at your own risk.

Jump to contentJump to page navigation: previous page [access key p]/next page [access key n]
Automated installation of SUSE Linux Enterprise Server using Agama
SUSE Linux Enterprise Server 16.0

Automated installation of SUSE Linux Enterprise Server using Agama

Publication Date: 24 Oct 2025
WHAT?

This article describes how to automatically install SUSE Linux Enterprise Server using Agama. The information presented here applies to unattended installation of the product on both bare metal and virtual machines.

WHY?

Read this article to understand the process of automatically installing SUSE Linux Enterprise Server using Agama.

EFFORT

You may need 30 minutes to read and understand the most important sections of this article. The time required for customization of Agama profiles and storage configuration depends on deployment requirements.

GOAL

Learn how to perform automated or unattended installation of SUSE Linux Enterprise Server using Agama.

REQUIREMENTS
  • A bare metal server or a virtual machine. For server installations without any desktop environment, SUSE recommends a minimum of 1 CPU, 2 GB memory and 32 GB storage (which includes storage for Btrfs snapshots in the root partition, swap space, and storage for software packages).

  • An image file for the product you want to install, downloaded from the SUSE Customer Center.

  • An active registration code for the product you want to install. You can generate a registration code for the product and activate its subscription for your organization at the SUSE Customer Center.

    Note
    Note: Optional registration

    Certain images that are signed with the developer's key may allow you to skip registration before or while installation. Besides, certain images may contain all installable packages for your operating system that you can use as an offline package repository. In such cases, you may not need an active registration code before installation. However, if you use software packages from the official online repositories, SUSE recommends registering your product with the SUSE Customer Center.

1 Introduction to automated installation using Agama

This article describes how to use Agama for automated and unattended installation of SUSE Linux Enterprise Server. You can use JSON profiles describing different aspects of intended system, and Agama installs accordingly. While not a fully backward compatible replacement for AutoYaST, it simplifies the task of automated installation and provides multiple clients for interactive and automated installation.

1.1 What is Agama

Agama as a service-based Linux installer capable of performing both interactive and unattended installations. You can provide Agama a JSON profile file detailing the initial system state, such as user authentication, partitioning, networking and software selection. On receiving the profile and instruction for installation from one of its supported clients, Agama installs your target system accordingly. Users can interact with and control the installation process using Agama's web-based user interface, command-line interface and HTTP API, facilitating automation and integration into existing workflows.

While Agama reuses many principles and internal components from previous SUSE installers like YaST and AutoYaST, and offers a high level of backwards compatibility for unattended installations, it is not a 100% compatible drop-in replacement for all AutoYaST features. Agama focuses only on the installation process rather than being a general configuration tool.

Agama server client architecture
Figure 1: Agama server client architecture

1.2 Why use Agama for automated installation

Agamaoffers its installation service by exposing an HTTP API, which you can use interactively from a web-based interface and a command-line interface (CLI), or provide a JSON profile to Agama for automated installation of a target system. Using the HTTP API you can also integrate with custom scripts and deployment tools. The benefits of using Agama for automated installation are as follows:

Focus on core installation

Agama focuses on core installation tasks such as user authentication, network configuration, storage setup and software installation, delegating further configuration to other tools such as Ansible Salt, Cockpit or OpenSCAP.

Profile based installation

You can define installation parameters for the target system in an easily readable and editable JSON or Jsonnet profile. Existing XML based AutoYaST are also supported with some exceptions.

Comprehensive profile configuration

The profile allows detailed setup including user authentication, product registration, network connections, storage (drives, partitions, LVM, RAID, encryption, resizing, deleting), software selection by patterns and packages, localization (language, keyboard, timezone) and many other aspects of the target system that are not exposed in the graphical or web-based interface. This helps in a more granular control over the installation parameters.

Dynamic profiles

Agama supports dynamic profiles using Jsonnet, injecting hardware information that can be processed at runtime. This avoids reliance on AutoYaST's rules or ERB for dynamic configurations.

AutoYaST compatibility

Agama offers a mechanism to reuse existing AutoYaST profiles to a great extent. It supports some dynamic features such as pre-scripts, rules/classes, and Embedded Ruby (ERB) when using AutoYaST profiles. A legacyAutoyastStorage section allows direct use of the AutoYaST profile's partitioning section for backwards compatibility.

Custom scripts

Profiles can define pre-installation, post-partitioning, chroot, and init scripts that run at specific stages. You can include scripts by URL, location in the hard drive, or embed the script content in the profile itself.

Easy initiation

The typical way to start an unattended installation from an ISO image is using the inst.auto kernel boot option, pointing to the profile URL or it's location in the hard drive. You can also use the agama profile import command from the Agama CLI to load a profile, followed by the agama install command. The CLI also allows inspection, modification, validation of the profile, and subsequent monitoring of the installation process.

2 Understanding Agama installation profiles

For automated installations, Agama relies on a profile, which is a configuration file that specifies how the system should be set up. This profile describes various aspects of the installation, including partitioning, networking, software selection, and other options. The concept of using a profile for automated installation is similar to AutoYaST. Agama focuses specifically on the installation process itself and delegates further system configuration to other tools. Agama aims for a high level of backward compatibility with AutoYaST profiles for automated installations.

Note
Note: Difference between Agama and AutoYaST profiles

Agama and AutoYaST profiles are largely compatible for all common use cases. However, Agama profiles are not fully compatible with AutoYaST profiles, and cannot be used as a drop-in replacement without checking the compatibility. There are certain aspects of the AutoYaST profiles that are currently supported in Agama profiles, or may be supported in the future. However, there are certain other aspects that are neither currently supported in Agama profiles, nor will be supported in the future. For more information, refer to the section Section 8, “Compatibility between AutoYaST and Agama profiles”.

2.1 Introduction to the Agama profile structure

Agama profile configuration is defined using a JSON document. It contains several sections that are necessary for describing the installation parameters for a customized system. At a high level, the profile consists of the following sections:

{
  "product": {}, 1
  "root": {}, 2
  "user": {}, 3
  "localization": {}, 4
  "hostname": {}, 5
  "software": {}, 6
  "storage": {}, 7
  "bootloader": {}, 8
  "network": {}, 9
  "security": {}, 10
  "scripts": {}, 11
  "files": {}, 12
  "legacyAutoyastStorage": {}, 13
  "iscsi": {}, 14
  "dasd": {} 15
}

1

product: Identifies the OS/product to be installed.

2

root: Root credentials for administrative access.

3

user: First non-root user account.

4

localization: Language, keyboard, and timezone settings.

5

hostname: Static/transient hostname settings.

6

software: Packages and patterns to be installed.

7

storage: Partitioning and mount configuration.

8

bootloader: Bootloader config and kernel params.

9

network: Network interface configuration.

10

security: SSL certs and other security settings.

11

scripts: Pre/post install scripting.

12

files: Inject additional files post-install.

13

legacyAutoyastStorage: Support for legacy AutoYaST JSON-style storage.

14

iscsi: iSCSI disk/target configuration.

15

dasd: DASD disk support for IBM Z (s390x).

You can also describe profiles using Jsonnet, which is a superset of JSON. Jsonnet offers features like variables, functions and more convenient syntax, making profiles more readable, concise, and dynamic for injecting hardware information at runtime.

For more information on the JSON and Jsonnet profiles, refer to the resources mentioned in the Section 9, “For more information” section. The upstream resources usually contains most updated information and examples about the profiles.

2.2 A minimal example of an Agama profile

A minimal Agama JSON profile must at least include sections for product identification, product registration, and credentials for the root user. Agama uses the defaults for the rest of the profile. As a best practice, you should also configure the following as a best practice:

A hostname
A non-root user
Minimal localization settings
Example 1: A minimal Agama profile for automated installation
{
  "product": {
    "id": "SUSE Linux Enterprise Server 16.0",
    "registrationCode": "REGISTRATION-CODE",
    "registrationEmail": "EMAIL",
  },
  "hostname": {
    "static": "STATIC-HOSTNAME",
    "transient": "TRANSIENT-HOSTNAME"
  },
  "root": {
    "hashedPassword": true,
    "password": "HASHED-ROOT-PASSWORD", 1
    "sshPublicKey": "SSH-PUBLIC-KEY", 2
  },
  "user": {
    "hashedPassword": false,
    "autologin": false,
    "fullName": "FULL-NAME",
    "userName": "USERNAME",
    "password": "PLAINTEXT-PASSWORD"
  },
  "localization": {
    "language": "LANGUAGE",
    "keyboard": "KEYBOARD-LAYOUT",
    "timezone": "TIMEZONE"
  }
}

1

You can generated a hashed password by running the following command:

> sudo openssl passwd -6

2

You can generate an SSH public key by running the following command:

> sudo ssh-keygen -t rsa -b 4096 -C "YOUR-EMAIL@EXAMPLE.COM"

Based on your requirements, choose the key type and the key size. However, it's better to adopt a stronger security.

To evaluate the correctness of the profile, run the following command:

> sudo agama profile validate AGAMA-PROFILE.json

3 Details of an Agama installation profile

The Agama profile contains various sections to configure different aspects of the system installation. For real deployments where you would want to simultaneously install multiple systems with the same initial configuration, prepare a customized profile with all the necessary details. You can start with the template of the minimal example and add details progressively. This section gives you an idea of the most useful details you should consider for real deployments.

3.1 Product configuration for an Agama installation profile

The product section defines the SUSE product to be installed and includes optional registration data and add-on modules. This is essential for systems requiring access to subscription repositories or additional functionality.

Example 2: Sample product configuration for an Agama installation profile
"product": {
  "id": "SUSE Linux Enterprise Server 16.0",
  "registrationCode": "REGISTRATION-CODE",
  "registrationEmail": "EMAIL-ADDRESS",
  "registrationUrl": "REGISTRATION-URL",
  "addons": [
    {
      "id": "ADDON-ID",
      "version": "ADDON-VERSION",
      "registrationCode": "ADDON-REGISTRATION-CODE"
    }
  ]
}

This section contains the following fields:

id

The product identifier used to select the base SUSE product to be installed.

registrationCode

The registration code for the product obtained from SUSE Customer Center, and used to activate repositories and receive updates.

registrationEmail

The email address associated with the registration account used during product activation.

registrationUrl

The full URL of the registration server. If you are using SUSE Customer Center, you can omit this field. However, it is useful when registering from a custom server.

addons

A list of optional add-on modules or extensions to be activated alongside the base product.

  • id: Identifier of the add-on. For example, sle-ha for High Availability.

  • version: Specific version of the add-on to be installed. This is required if multiple versions are available.

  • registrationCode: Optional registration code for the add-on if separate activation is required.

3.2 Hostname configuration for an Agama installation profile

The hostname section sets the system's static and transient hostname. The static hostname is persistent across reboots, while the transient hostname is used temporarily at runtime and may be overridden by network services like DHCP.

Example 3: Sample hostname configuration for an Agama installation profile
"hostname": {
  "static": "STATIC-HOSTNAME",
  "transient": "TRANSIENT-HOSTNAME"
}

This section contains the following fields:

static

The persistent hostname written to /etc/hostname. This name remains consistent across system reboots and is used by default if no transient hostname is specified.

transient

A temporary hostname applied at runtime. This may be used during deployment or installation to reflect an ephemeral identity. For example, it can be set via DHCP or by installation tooling like Agama.

3.3 Root authentication for an Agama installation profile

The root section defines authentication settings for the system's root account. This includes a root password (either plain or pre-hashed) and an optional SSH public key for remote access.

Example 4: Sample root configuration for an Agama installation profile
"root": {
  "hashedPassword": true,
  "password": "HASHED-ROOT-PASSWORD",
  "sshPublicKey": "SSH-PUBLIC-KEY"
}

This section contains the following fields:

hashedPassword

Boolean flag indicating whether the password field contains a hashed value. If set to true, the password must be a SHA-512 crypt hash (starting with $6$). If false or omitted, the value is treated as plain text.

password

The root user's password. If hashedPassword is true, this must be a pre-generated hash (For example, using openssl passwd -6). Otherwise, plain text is accepted and will be hashed during installation.

You can generated a hashed password by running the following command:

> sudo openssl passwd -6
sshPublicKey

An optional SSH public key to be added to the root user's ~/.ssh/authorized_keys file. This allows passwordless root login over SSH. The key must be in OpenSSH format. For example, starting with ssh-rsa or ssh-ed25519.

You can generate an SSH public key by running the following command:

> sudo ssh-keygen -t rsa -b 4096 -C "YOUR-EMAIL@EXAMPLE.COM"

Based on your requirements, choose the key type and the key size. However, it's better to adopt a stronger security.

3.4 User configuration for an Agama installation profile

The user section defines the initial non-root user account created during installation. This includes the user's full name, login name, password (plain or hashed), and optional automatic login preference.

Example 5: Sample user configuration for an Agama installation profile
"user": {
  "hashedPassword": false,
  "fullName": "FULL-NAME",
  "userName": "LOGIN-NAME",
  "password": "USER-PASSWORD",
  "autologin": false
}

This section contains the following fields:

hashedPassword

Boolean flag indicating whether the password field contains a hashed value. If set to true, the password must be a pre-hashed SHA-512 crypt value. Otherwise, the plain text password will be hashed during installation.

fullName

The full name of the user, typically used for display purposes in graphical environments. For example, Jane Doe.

userName

The system login name for the user. This becomes their Linux username and home directory under /home. For example, jane.

password

The user's password, in plain text or pre-hashed depending on the hashedPassword flag. If plaintext is provided, it will be automatically hashed.

autologin

Optional boolean that determines whether the user should be automatically logged into a graphical session at boot. This setting is only relevant for desktop installations.

3.5 Localization configuration for an Agama installation profile

The localization section defines the system language, keyboard layout, and time zone settings. These parameters determine the default locale and input behavior after installation.

Example 6: Sample localization configuration for an Agama installation profile
"localization": {
  "language": "LANGUAGE-ID",
  "keyboard": "KEYBOARD-LAYOUT",
  "timezone": "TIMEZONE"
}

This section contains the following fields:

language

The system language and locale, specified as a locale string. For example, en_US.UTF-8 or de_DE. This controls messages, number formats, date formats, and default encoding.

keyboard

The default keyboard layout identifier. For example, us or de. This affects key mapping on both text consoles and graphical desktops.

timezone

The system time zone, using a region/location format. For example, Europe/Berlin. This sets the default system clock and affects date/time display.

3.6 Software configuration for an Agama installation profile

The software section defines which software components are installed on the system via SUSE's pattern and package management infrastructure.

Example 7: Sample software configuration for an Agama installation profile
"software": {
  "patterns": [
    "minimal_base",
    "app_server"
  ],
  "packages": [
    "vim",
    "htop",
    "curl"
  ]
}

This section contains the following fields:

patterns

A list of software patterns to be installed. Patterns are curated collections of packages designed to serve a functional role. For example, minimal_base, gnome, app_server. For a complete list of patterns available for SUSE Linux Enterprise Server and your target architecture, refer to the SUSE Customer Center.

packages

A list of individual packages to install in addition to those brought in by selected patterns. For example, vim, htop and curl. For a complete list of packages available from the official SUSE Linux Enterprise Server repositories for your target architecture, refer to the SUSE Customer Center.

Note
Note: Trust the GPG key for the Package Hub repository

When enabling SUSE Package Hub during a manual installation, users are prompted to trust the repository's GPG key. To trust the key automatically during an unattended installation, use the following snippet:

{
  product: {
    id: 'SLES',
    registrationCode: 'SLES_REG_CODE',
    addons: [
      {
        id: 'PackageHub',
      }
    ]
  },
  questions: {
    policy: 'auto',
    answers: [
      {
        answer: 'Trust',
        class: 'software.import_gpg',
        data: {
          fingerprint: 'BF3F 9A67 D3A2 FF98 A73F 5E07 488C 583D 287A 0027',
          name: 'openSUSE Backports for SUSE Linux 16 sle-backports-202500514@opensuse.org',
          id: '488C583D287A0027'
        }
      }
    ]
  }
}

3.7 Storage configuration for an Agama installation profile

The storage section defines the system's target disk layout, such as partitions, filesystems, and volume management, to be applied during installation. This field references the Agama storage schema, which is referenced from the profile schema.

Note
Note: Advanced storage configuration

An exhaustive description of all possible storage configuration using Agama is beyond the scope of this section, as it will need a careful consideration of the storage model schema. For information on advanced storage configuration, refer to the section Section 7, “Advanced storage configuration using Agama profiles”.

Example 8: Sample storage configuration for an Agama installation profile
"storage": {
  "disks": [
    {
      "device": "/dev/sda",
      "partitions": [
        {
          "mountPoint": "/",
          "fsType": "ext4",
          "size": "20G"
        },
        {
          "mountPoint": "swap",
          "fsType": "swap",
          "size": "4G"
        }
      ]
    }
  ]
}

This section contains the following fields:

disks

A list of disks on which partitions will be defined.

  • device: The full device path, such as /dev/sda.

  • partitions: A list of partitions to create on the disk.

    • mountPoint: The mount point for the partition, or swap for swap areas.

    • fsType: Filesystem type, such as ext4 or swap.

    • size: Size of the partition (e.g., 20G).

3.8 Bootloader configuration for an Agama installation profile

The bootloader section defines boot-time behavior, including whether to pause at the boot menu and what extra kernel parameters to pass. It affects the installed system's GRUB configuration.

Example 9: Sample bootloader configuration for an Agama installation profile
"bootloader": {
  "stopOnBootMenu": false,
  "timeout": 5,
  "extraKernelParams": "KERNEL-PARAMETERS"
}

This section contains the following fields:

stopOnBootMenu

Boolean flag that, if set to true, forces the system to stop at the GRUB boot menu instead of proceeding automatically. This is useful for debugging or choosing alternate boot options manually.

timeout

Number of seconds the GRUB boot menu is shown before continuing with the default entry. Set to 0 to boot immediately.

extraKernelParams

Additional kernel command-line parameters to append to the default ones during boot. These are passed directly to the Linux kernel. For example, console=ttyS0 or quiet splash.

3.9 Network configuration for an Agama installation profile

The network section defines one or more network connections to be configured during installation. Each connection supports IP setup, interface binding, wireless settings, bonding, bridging, and optional enterprise-grade authentication mechanisms like IEEE 802.1X.

Example 10: Sample network configuration for an Agama installation profile
"network": {
  "connections": [
    {
      "id": "ETH0-CONNECTION",
      "interface": "eth0",
      "method4": "manual",
      "addresses": ["192.168.100.10/24"],
      "gateway4": "192.168.100.1",
      "nameservers": ["1.1.1.1", "8.8.8.8"],
      "autoconnect": true
    },
    {
      "id": "WIFI-HOME",
      "interface": "wlan0",
      "method4": "auto",
      "wireless": {
        "ssid": "MYSSID",
        "password": "MYWIFIPASSWORD",
        "security": "wpa-psk"
      }
    },
    {
      "id": "BRIDGE0",
      "interface": "br0",
      "method4": "auto",
      "bridge": {
        "stp": true,
        "forwardDelay": 15,
        "ports": ["eth0", "eth1"]
      }
    },
    {
      "id": "BOND0",
      "interface": "bond0",
      "method4": "manual",
      "addresses": ["10.0.0.100/24"],
      "gateway4": "10.0.0.1",
      "bond": {
        "mode": "active-backup",
        "options": "miimon=100",
        "ports": ["eth2", "eth3"]
      }
    },
    {
      "id": "SECURE-ETH",
      "interface": "eth4",
      "method4": "auto",
      "ieee-8021x": { 1
        "eap": ["peap"],
        "identity": "USERNAME",
        "password": "PASSWORD",
        "caCert": "/etc/certs/ca.pem"
      }
    }
  ]
}

1

Note
Note

Support for IEEE 802.1X authentication is intended for advanced enterprise deployments where authentication is required at the link layer, before IP is assigned. This commonly involves integration with RADIUS and certificate-based trust. Misconfiguration can result in complete network inaccessibility. Refer to systemd-networkd documentation for authoritative guidance.

This section contains the following connection attributes:

id

Unique name for the network connection.

interface

Name of the network interface to bind to (for example, eth0).

method4

IPv4 addressing method (auto, manual, etc.).

method6

IPv6 addressing method (auto, manual, etc.).

addresses

List of static addresses in CIDR format.

gateway4 / gateway6

IPv4 and IPv6 default gateway addresses.

nameservers

List of DNS server IPs.

autoconnect

Boolean. Whether the connection is brought up automatically.

wireless

Defines wireless-specific settings:

  • ssid: Wi-Fi network name.

  • password: Wi-Fi passphrase.

  • security: Key management (for example, wpa-psk).

bridge

Defines bridge-specific settings:

  • stp: Boolean. Enables Spanning Tree Protocol.

  • forwardDelay: STP forwarding delay in seconds.

  • ports: Interfaces to include in the bridge.

bond

Defines bonding configuration:

  • mode: Bonding mode (for example, active-backup).

  • options: Optional bonding parameters (for example, miimon=100).

  • ports: List of interfaces in the bond.

ieee-8021x

Defines enterprise authentication settings:

  • eap: List of EAP methods (for example, peap, tls).

  • identity: Login identity (typically username).

  • password: Authentication password (if needed).

  • caCert: Path to trusted CA certificate.

3.10 Security configuration for an Agama installation profile

The security section allows you to add trusted SSL certificates to the installed system. This is useful when connecting to internal package mirrors, registration servers, or other TLS services that require non-default certificate authorities.

Example 11: Sample security configuration for an Agama installation profile
"security": {
  "sslCertificates": [
    {
      "fingerprint": "FINGERPRINT",
      "algorithm": "SHA256"
    }
  ]
}

This section contains the following fields:

sslCertificates

A list of custom SSL certificates to install into the system’s trust store. Each item specifies the certificate’s fingerprint and the hashing algorithm used.

  • fingerprint: The cryptographic fingerprint of the certificate, formatted as a colon-separated hex string. For example, A8:DE:08:B1:57:52:FE:70:DF:D5:31:EA:E3:53:BB:39:EE:01:FF:B9.

  • algorithm: The fingerprint algorithm used to compute the hash. Supported values are SHA1 and SHA256.

    Warning
    Warning: Use SHA256 for better security

    SHA1 is cryptographically broken and should not be used. Use SHA256 wherever possible.

To verify the fingerprint of a certificate in PEM format:

> sudo openssl x509 -in FILE.pem -noout -fingerprint -sha256

Trusted certificates can be installed permanently by placing them in /etc/pki/trust/anchors and then executing:

> sudo update-ca-certificates

3.11 Scripts configuration for an Agama installation profile

The scripts section allows you to define custom shell scripts to be executed at different stages of the SUSE installation lifecycle. These scripts can be embedded inline, fetched from a URL, and optionally executed in a chroot environment (where applicable).

Example 12: Sample scripts configuration for an Agama installation profile
"scripts": {
  "pre": [
    {
      "name": "PRE-CHECK-DISK.sh",
      "content": "#!/bin/bash\nif [ ! -e /dev/sda ]; then echo 'Disk not found' >&2; exit 1; fi"
    }
  ],
  "postPartitioning": [
    {
      "name": "CREATE-MOUNTS.sh",
      "url": "http://EXAMPLE.COM/SCRIPTS/MOUNTS.sh"
    }
  ],
  "post": [
    {
      "name": "FINALIZE-INSTALL.sh",
      "content": "#!/bin/bash\necho 'Installation complete'",
      "chroot": true
    }
  ],
  "init": [
    {
      "name": "FIRST-BOOT.sh",
      "content": "#!/bin/bash\necho 'System booted for the first time'"
    }
  ]
}

This section defines the following script categories:

pre

Scripts executed before the installation begins. Useful for pre-flight checks or environment preparation.

postPartitioning

Scripts run immediately after partitioning is completed, but before packages are installed.

post

Scripts run after installation finishes. These can optionally execute within the target system’s root via chroot.

init

Scripts executed during the first boot of the installed system. These are useful for final configuration, logging, or notifications.

Each script object may contain one of the following keys:

name

File name used to identify the script on disk. Required for all scripts.

content

Inline script body. Must begin with a shebang (for example, #!/bin/bash).

url

HTTP/HTTPS location from which to fetch the script. Cannot be combined with content.

chroot

Boolean. If true, the script is executed inside the installed system’s root via chroot. Applies only to post scripts.

3.12 Files configuration for an Agama installation profile

The files section allows deployment of custom user-defined files into the installed system. These files are written just before post-installation scripts run and can be useful for configuring services, dropping keys, or overriding system files.

Example 13: Sample files configuration for an Agama installation profile
"files": [
  {
    "destination": "ABSOLUTE-FILE-PATH",
    "content": "FILE-CONTENT",
    "permissions": "0644",
    "user": "USERNAME",
    "group": "GROUPNAME"
  }
]

This section contains an array of file definitions. Each entry supports the following fields:

destination

Required absolute path where the file will be written inside the target system. For example, /etc/MYAPP/CONFIG.YAML.

content

Inline string representing the content of the file. This field is mutually exclusive with url; one of the two must be present.

url

URL (relative or absolute) to fetch the file content from. Used instead of inline content. One of url or content is required.

permissions

Optional file mode string (octal), such as 0644 or 0755, to set on the created file.

user

Optional owner username to assign to the file. The user must already exist in the installed system.

group

Optional owner group to assign to the file. The group must already exist in the installed system.

3.13 Legacy AutoYaST storage configuration for an Agama installation profile

The legacyAutoyastStorage section allows reuse of AutoYaST-style storage definitions by expressing them in JSON. It accepts an array of opaque objects directly representing the legacy partitioning structure, allowing migration or backward compatibility for existing storage configurations.

Example 14: Sample legacyAutoyastStorage configuration for an Agama installation profile
"legacyAutoyastStorage": [
  {
    "partitions": {
      "partition": [
        {
          "device": "/dev/sda1",
          "mount": "/",
          "size": "20G",
          "filesystem": "ext4"
        },
        {
          "device": "/dev/sda2",
          "mount": "swap",
          "size": "4G",
          "filesystem": "swap"
        }
      ]
    }
  }
]

This section contains the following:

legacyAutoyastStorage

An array of JSON objects compatible with the XML structure used in AutoYaST’s partitioning section. This allows experienced administrators to reuse complex partitioning logic without switching to Agama-native storage syntax.

3.14 iSCSI configuration for an Agama installation profile

The iscsi section defines parameters required for configuring iSCSI targets that should be discovered and mounted during system installation. This is particularly relevant for systems that boot from SAN or use iSCSI-based storage volumes.

Example 15: Sample iSCSI configuration for an Agama installation profile
"iscsi": {
  "initiatorName": "IQN-OF-INITIATOR",
  "targets": [
    {
      "address": "TARGET-IP",
      "port": 3260,
      "target": "IQN-OF-TARGET",
      "user": "CHAP-USERNAME",
      "password": "CHAP-PASSWORD",
      "autoLogin": true
    }
  ]
}

This section contains the following configuration keys:

initiatorName

The iSCSI initiator name (IQN) of the client system. Must follow the iSCSI naming convention. For example, iqn.2025-05.com.suse:agama-client.

targets

An array of target definitions to connect to. Each target supports the following fields:

  • address: IP address or hostname of the iSCSI target.

  • port: TCP port of the target. Default is 3260.

  • target: IQN of the iSCSI target to connect to.

  • user and password: CHAP authentication credentials, if required by the target.

  • autoLogin: Boolean flag indicating whether to automatically log in to the target during boot.

3.15 DASD devices configuration for an Agama installation profile

The dasd section is used to activate, configure, or format Direct Access Storage Device (DASD) volumes on IBM Z (s390x) systems. It is relevant only when installing SUSE on mainframe hardware.

Example 16: Sample dasd devices configuration for an Agama installation profile
"dasd": {
  "devices": [
    {
      "channel": "0.0.1234",
      "state": "active",
      "format": true,
      "diag": false
    },
    {
      "channel": "0.0.5678",
      "state": "offline"
    }
  ]
}

This section defines the following keys:

devices

A list of DASD devices to configure. Each device is represented as an object with the following fields:

  • channel: Required. The device channel path, typically in the format 0.0.xxxx.

  • state: Optional. Indicates whether the device should be made active or put offline. Defaults to active.

  • format: Optional. Boolean indicating whether the device should be formatted. If unspecified, formatting happens only if necessary.

  • diag: Optional. Boolean indicating whether the device should have its diagnostic (diag) flag set. If unspecified, the existing state is preserved.

4 Using AutoYaST profiles with Agama

Agama introduces a modern, declarative installation framework that diverges significantly from the legacy AutoYaST system, even though both aim to automate SUSE Linux Enterprise Server deployments. While partial reuse of existing AutoYaST profiles is possible, direct compatibility is limited due to schema differences, semantic mismatches, and architectural shifts. This topic outlines how to load AutoYaST profiles in Agama, identifies supported modules, and offers practical guidance for converting legacy profiles using recommended tools and conventions.

4.1 Benefits of using AutoYaST profiles in Agama

Reusing existing AutoYaST profiles in Agama provides a pragmatic starting point for teams migrating to the new installer without discarding prior investments. Although direct compatibility is limited, leveraging AutoYaST profiles accelerates transition efforts by retaining core configuration logic, organizational conventions, and validated deployment workflows.

Using AutoYaST profiles in Agama has the following benefits:

Reduced duplication of effort

Existing infrastructure-as-code assets can inform Agama profile structure, minimizing rework.

Faster onboarding

Administrators familiar with AutoYaST can map known modules to Agama fields incrementally.

Incremental migration

Supported AutoYaST elements can be reused while unsupported ones are refactored or omitted over time.

Validation of system assumptions

Reviewing legacy profiles helps surface deprecated patterns and adapt them to Agama’s declarative model.

4.2 Limitations of using AutoYaST profiles in Agama

While reusing AutoYaST profiles in Agama may provide a head start during migration, it also introduces significant limitations. The fundamental differences in schema structure, execution model, and configuration philosophy mean that AutoYaST-based profiles can constrain the effectiveness and clarity of Agama workflows if carried over directly.

Using AutoYaST profiles in Agama has the following limitations:

Procedural bias

AutoYaST profiles often rely on execution order, embedded scripts, and imperative constructs, which have no counterpart in Agama’s declarative design.

Semantic mismatch

Many AutoYaST modules encapsulate behavior or assumptions not explicitly modeled in Agama, leading to subtle incompatibilities or misconfigurations during reuse.

Reduced transparency

Profiles imported from AutoYaST tend to obscure the declarative simplicity of Agama, making troubleshooting and peer review harder.

Missed modernization opportunities

Clinging to legacy profiles may prevent users from fully adopting Agama’s modular, readable, and cloud-native configuration style.

4.3 Loading AutoYaST profiles with Agama

Agama supports loading AutoYaST profiles as part of its transitional support for legacy automation systems. This allows administrators to reuse existing configuration assets while gradually migrating to the native Agama profile format. Several loading mechanisms are available depending on the deployment context and profile structure.

Procedure 1: Loading an AutoYaST profile using Agama

Use the following steps to load an AutoYaST profile in Agama. Profiles can be supplied either through kernel boot parameters or imported using the Agama CLI.

  1. Select a method for providing the AutoYaST profile to Agama:

    • Load the profile using a kernel boot parameter. Add the inst.auto parameter to the kernel command line and specify the URL of the AutoYaST profile:

      > sudo linux inst.auto=http://EXAMPLE.NET/AGAMA/SLES.xml

      This method is commonly used in PXE boot setups or custom ISO builds.

    • Import the profile using the Agama CLI. Run the following command to fetch and preprocess the AutoYaST profile:

      > sudo agama profile import URL

      Supported formats include:

      • Agama profiles: .json, .jsonnet, .sh

      • AutoYaST profiles: .xml, .erb, and directories such as rules/ or classes/

      For more information on supported URL types, refer to https://agama-project.github.io/docs/user/urls.

      When importing AutoYaST content, the CLI automatically evaluates dynamic features such as:

      • Rules and classes for conditional profile selection

      • Embedded Ruby (ERB) for template-based profile generation

      • Pre-installation scripts to dynamically modify profile content

  2. Display the loaded or imported profile, or pip[e it to a JSON file:

    > sudo agama config show > profile.json

4.4 Best practices for converting AutoYaST profiles to Agama profiles

Converting AutoYaST profiles to Agama profiles involves transforming the original XML into Agama's JSON or Jsonnet format. This procedure outlines the recommended steps using the Agama CLI.

Procedure 2: Best practices for converting AutoYaST profiles to Agama profiles
  1. Convert the AutoYaST profile to a JSON file by piping the CLI output to a destination file:

    > sudo agama profile autoyast http://EXAMPLE.NET/AUTOYAST.xml > profile.json

    This command fetches and processes the AutoYaST profile, then writes the resulting Agama-compatible JSON to the specified file.

  2. Validate the converted profile:

    > sudo agama profile validate profile.json

    This ensures schema compliance and helps identify any unsupported or misconverted fields.

  3. Manually rework or remove unsupported sections, using Agama's schema documentation as a reference.

  4. If you require dynamic behavior, convert the profile to Jsonnet. You can then evaluate it into JSON:

    > sudo agama profile evaluate profile.jsonnet > profile.json
  5. Test the final profile by loading it into an Agama installation session:

    > sudo agama config load profile.json
  6. Make final edits to the loaded profile before starting installation:

    > sudo agama config edit

5 Initiating automated installation using Agama

This topic guides you through starting an automated installation using Agama. You can initiate the process either by specifying boot parameters or by using the Agama command-line interface.

5.1 Initiating the unattended installation

Procedure 3: Initiating the unattended installation
  1. Start the installation using kernel boot parameters.

    Add the inst.auto parameter to the kernel command line to specify the location of the Agama profile:

    > sudo linux inst.auto=http://example.net/profile.json

    This method is suitable for PXE boot setups, custom ISO builds, or cloud-init workflows.

    For more information on boot options, refer to https://agama-project.github.io/docs/user/boot_options.

  2. Start the installation using the Agama CLI.

    1. Validate the profile:

      > sudo agama profile validate profile.json
    2. Import the profile with the following command:

      > sudo agama profile import
      profile.json

      If importing a dynamic profile using a Jsonnnet file, Agama handles dynamic features such as rules, classes, and embedded Ruby (ERB) templates.

      For information on the supported URL types for validation and import, refer to https://agama-project.github.io/docs/user/urls.

    3. Initiate the installation with the following command:

      > sudo agama install
    4. Monitor the installation with the following command:

      > sudo agama monitor

6 Post installation troubleshooting of automated installation using Agama

Introductory text

6.1 Introduction

A paragraph of text.

6.2 Requirements

  • An

  • Unordered

  • List

A paragraph of text.

6.3 Executing the task

A paragraph of text.

A short introduction to the procedure.

  1. A step.

  2. A second step.

  3. A third step.

6.4 Summary

A paragraph of text, summing up the result of the task.

6.5 Troubleshooting

Add some troubleshooting information, if applicable.

7 Advanced storage configuration using Agama profiles

Storage configuration in Agama is one of the most powerful and flexible components of the automated installation process. It allows you to declaratively define everything from simple partition layouts to sophisticated combinations of LUKS encryption, Logical Volume Management (LVM), software RAID, and Btrfs subvolumes — all before the system is booted for the first time.

This topic primarily describes the Agama storage schema as described in https://github.com/agama-project/agama/blob/master/rust/agama-lib/share/storage.schema.json. Each section in this topic focuses on a specific capability or concept: basic partitions, encrypted volumes, nested logical volumes, RAID configurations, Btrfs setups, and advanced directives like preservation flags or formatting instructions. Together, they enable reproducible, secure, and scalable disk layout management suitable.

Although a minimal configuration might only need one disk and one mount point, a more detailed storage model enables production-ready deployment pipelines, disaster recovery consistency, and tight security controls from the first boot.

7.1 Top-level schema elements

At the highest level, the storage section in the Agama profile is an array of disk configuration objects. Each object describes a physical or virtual block device, and how partitions or logical volumes should be created on it. These objects live under the top-level storage key in the profile schema.

Note
Note: Minimal top-level storage

The following example illustrates only the bare minimum needed to define a disk object. It does not reflect the full capabilities of the Agama storage model such as partitioning, encryption, volume management, or reuse behavior. These topics are covered in later sections.

Example 17: Minimal top-level storage entry
[
  {
    "type": "disk",
    "device": "/dev/sda",
    "wipe": true,
    "partitions": []
  }
]

7.2 Filesystems partitions

Standard partitions are used to create filesystems directly on a disk. These are the most common storage entities and are defined under the partitions array inside a disk object. Each partition can specify properties like mount points, filesystems type, format behavior, and reuse preferences.

The example below demonstrates a configuration that sets up two partitions: one EFI system partition and one root partition formatted with XFS.

Example 18: Partitioned disk with EFI and root filesystems
[
  {
    "type": "disk",
    "device": "/dev/sda",
    "wipe": true,
    "partitions": [
      {
        "type": "efi",
        "size": 256,
        "mountPoint": "/boot/efi",
        "preserve": false,
        "format": true
      },
      {
        "type": "partition",
        "mountPoint": "/",
        "fsType": "xfs",
        "size": 20480,
        "preserve": false,
        "format": true
      }
    ]
  }
]

This section contains the following elements:

type

Either efi or partition. Determines how the partition is treated.

size

Size of the partition in MiB. If omitted, the remaining space is used.

mountPoint

Mount point inside the target filesystems. Must be specified unless the partition is unmounted.

fsType

Filesystems type, such as xfs, ext4, or btrfs. Required unless format is false.

preserve

Boolean flag. When true, existing data on this partition is preserved. Defaults to false.

format

Boolean flag. When true, the partition will be freshly formatted. Defaults to true unless preserve is set.

7.3 LUKS encryption

Agama supports encrypting block devices using LUKS. Encrypted devices can be used as mountable filesystems or as physical volumes in LVM setups. Each encrypted block must define its own passphrase or refer to a key file.

The example below shows a basic LUKS-encrypted root partition, created inside a disk and mounted as the system root.

Example 19: Root filesystem encrypted with LUKS
[
  {
    "type": "disk",
    "device": "/dev/sda",
    "wipe": true,
    "partitions": [
      {
        "type": "efi",
        "size": 256,
        "mountPoint": "/boot/efi",
        "format": true,
        "preserve": false
      },
      {
        "type": "crypt",
        "name": "cryptroot",
        "cipher": "aes-xts-plain64",
        "keySize": 512,
        "password": "MY-SECRET-PASSWORD",
        "volume": {
          "type": "partition",
          "mountPoint": "/",
          "fsType": "xfs",
          "size": 20480,
          "format": true,
          "preserve": false
        }
      }
    ]
  }
]

This section contains the following elements:

type

Must be set to crypt to declare a LUKS encrypted volume.

name

Name for the mapped LUKS device, used in /dev/mapper.

cipher

Encryption cipher. For example, aes-xts-plain64.

keySize

Key size in bits. Common values are 256 or 512.

password

The passphrase used to unlock the encrypted volume. Can be replaced with keyFile if using an external key.

volume

The block device definition that will reside within the LUKS container. Often a single partition, but can also be a volume group.

7.4 Logical Volume Management (LVM)

Logical Volume Management allows aggregating multiple block devices or partitions into a single logical storage pool. In Agama, LVM setups are described using a volumeGroup type, under which logical volumes are listed.

Example 20: LVM setup with a single logical volume
[
  {
    "type": "disk",
    "device": "/dev/sda",
    "wipe": true,
    "partitions": [
      {
        "type": "partition",
        "size": 30720,
        "volume": {
          "type": "volumeGroup",
          "name": "systemvg",
          "volumes": [
            {
              "name": "home",
              "mountPoint": "/home",
              "fsType": "xfs",
              "size": 20480,
              "format": true,
              "preserve": false
            }
          ]
        }
      }
    ]
  }
]

This section contains the following elements:

type

Set to volumeGroup to define a new LVM volume group container.

name

Name of the volume group. Used for identifying the group in /dev/<vg-name>/.

volumes

List of logical volumes within this volume group. Each volume is defined using fields like name, mountPoint, fsType, and size.

7.5 RAID configuration

Agama allows defining software RAID arrays directly within the storage configuration using the mdraid type. You can specify the RAID level, involved devices, chunk size, and metadata version, among other options. These arrays can be used as mountable volumes or serve as physical volumes in LVM or encryption stacks.

Example 21: Basic RAID 1 setup with /home mounted
[
  {
    "type": "disk",
    "device": "/dev/sda",
    "wipe": true
  },
  {
    "type": "disk",
    "device": "/dev/sdb",
    "wipe": true
  },
  {
    "type": "mdraid",
    "level": "1",
    "devices": ["/dev/sda", "/dev/sdb"],
    "volume": {
      "type": "partition",
      "mountPoint": "/home",
      "fsType": "xfs",
      "size": 10240,
      "format": true,
      "preserve": false
    }
  }
]

This section includes the following elements:

type

Must be set to mdraid to define a software RAID device.

level

The RAID level to use (e.g., 0, 1, 5, 6, or 10).

devices

List of block devices that participate in the array.

volume

The volume definition describing what should be created on top of the RAID array. It may be a regular filesystem partition, a LUKS container, or an LVM setup.

7.6 Btrfs layout

Agama supports configuring Btrfs subvolumes and mount points, allowing granular control over snapshot-aware filesystems. You can define a top-level Btrfs partition or volume, then define subvolumes under it, each optionally with its own mount point.

Example 22: Btrfs setup with multiple subvolumes
[
  {
    "type": "disk",
    "device": "/dev/sda",
    "wipe": true,
    "partitions": [
      {
        "type": "btrfs",
        "mountPoint": "/",
        "format": true,
        "subvolumes": [
          {
            "name": "@home",
            "mountPoint": "/home"
          },
          {
            "name": "@log",
            "mountPoint": "/var/log"
          }
        ]
      }
    ]
  }
]

This section includes the following elements:

type

Must be set to btrfs to define a Btrfs partition.

mountPoint

The mount point for the root of the Btrfs volume (e.g., /).

format

Whether to format the Btrfs partition. Must be set to true to create new filesystems.

subvolumes

List of Btrfs subvolumes. Each subvolume is an object with at least a name, and optionally a mountPoint.

  • name: The name of the Btrfs subvolume (e.g., @home).

  • mountPoint: Mount point for this subvolume (e.g., /home).

7.7 Partition flags and modifiers

Flags and attributes that influence partition behavior, naming, sizing, and boot compatibility.

Example 23: Example with partition flags and metadata
[
  {
    "type": "disk",
    "device": "/dev/sda",
    "wipe": true,
    "partitions": [
      {
        "mount": "/boot",
        "size": 512,
        "filesystem": "ext4",
        "esp": true,
        "grow": false,
        "label": "BOOT",
        "id": "boot-partition"
      }
    ]
  }
]

This section describes the following partition attributes:

grow

If set to true, this partition or volume will take up any leftover space after allocating other defined volumes.

esp

Marks the partition as an EFI System Partition. This is required for UEFI boot setups when using a separate /boot partition.

label

Human-readable label to assign to the partition or logical volume. For example, HOME or BOOT.

id

Unique identifier used to reference this partition in other sections or mount relationships. Optional, but useful for referencing volumes in complex setups.

7.8 Reusing existing volumes

To preserve data or reuse partitions from a previous installation, Agama supports marking individual storage entries with preserve: true. This avoids reformatting or wiping the specified device or volume.

Example 24: Reusing an existing /home partition
[
  {
    "type": "disk",
    "device": "/dev/sda",
    "wipe": false,
    "partitions": [
      {
        "mount": "/home",
        "preserve": true,
        "id": "home-partition"
      }
    ]
  }
]

This section describes the relevant flag:

preserve

If true, the existing content of the volume will not be deleted or reformatted. This is useful when retaining data directories like /home or reuse across installations. The target must already be formatted with a valid filesystem.

7.9 Real-world example configurations

Here are several end-to-end examples illustrating common and practical storage layouts.

Example 25: UEFI layout with root, home, and swap
[
  {
    "type": "disk",
    "device": "/dev/sda",
    "wipe": true,
    "partitions": [
      {
        "mount": "/boot/efi",
        "size": 256,
        "filesystem": "vfat",
        "esp": true
      },
      {
        "mount": "/",
        "size": 20480,
        "filesystem": "btrfs",
        "label": "ROOT"
      },
      {
        "mount": "/home",
        "size": 10240,
        "filesystem": "xfs",
        "label": "HOME"
      },
      {
        "filesystem": "swap",
        "size": 4096
      }
    ]
  }
]
Example 26: LVM-backed root and home partitions
[
  {
    "type": "disk",
    "device": "/dev/sda",
    "wipe": true,
    "partitions": [
      {
        "type": "lvm",
        "id": "pv-system"
      }
    ]
  },
  {
    "type": "lvm_vg",
    "id": "vg-system",
    "devices": ["pv-system"],
    "volumes": [
      {
        "mount": "/",
        "size": 10240,
        "filesystem": "btrfs",
        "label": "ROOT"
      },
      {
        "mount": "/home",
        "size": 20480,
        "filesystem": "xfs",
        "label": "HOME"
      }
    ]
  }
]
Example 27: Encrypted LUKS root filesystem
[
  {
    "type": "disk",
    "device": "/dev/sda",
    "wipe": true,
    "partitions": [
      {
        "mount": "/boot",
        "size": 512,
        "filesystem": "ext4"
      },
      {
        "type": "luks",
        "id": "crypt-root"
      }
    ]
  },
  {
    "type": "luks_open",
    "id": "decrypted-root",
    "device": "crypt-root",
    "name": "cryptroot",
    "filesystem": "btrfs",
    "mount": "/",
    "label": "ROOT"
  }
]

7.10 Partition type reference

The following types are valid values for the type field in the Agama storage schema. Each type describes a different layer or behavior in the storage stack.

disk

Represents a physical or virtual block device. It contains a list of partitions or other volume definitions.

partition

Represents a filesystem partition on a disk. Most commonly used for mount points like /boot, /home, or /.

luks

Marks a partition to be encrypted using LUKS. Must be opened later using luks_open.

luks_open

Refers to an encrypted volume defined via luks. It allows specifying filesystem and mount point on the decrypted device.

lvm

Initializes a partition as a physical volume (PV) for LVM. Used in combination with lvm_vg.

lvm_vg

Defines a volume group that aggregates one or more PVs. Contains logical volumes with their own mount points and filesystems.

mdraid

Used to define software RAID arrays (e.g., RAID1, RAID5) over multiple disks or partitions.

btrfs_subvolume

Defines a Btrfs subvolume and mount point within a Btrfs-formatted volume. Requires a parent Btrfs filesystem to exist.

7.11 Common pitfalls and edge cases

This section outlines frequently encountered mistakes and gotchas that can lead to installation failures or misconfigured systems when using Agama's storage schema.

  • Missing or incorrect id fields: Every volume layer (disk, partition, luks, lvm, etc.) should have a unique and predictable id. Reusing IDs or leaving them out leads to ambiguous device paths during setup.

  • Forgetting to mount the root volume: If no volume has a mount set to /, the system will not boot properly.

  • Not marking a bootable ESP for EFI systems: UEFI-based installations must have an EFI System Partition (esp: true) mounted at /boot/efi.

  • Overlapping device references: Using the same partition or device in more than one storage object (e.g., as both LUKS and plain partition) can result in failed setups.

  • Incorrect vg names in LVM: Ensure that the vg names in LVM volumes match exactly with the defined id of their respective lvm_vg parent objects.

  • Using preserve: true without id: Agama requires the preserved volume to be clearly referenced. Omitting id or device fields for preserved objects can break the reuse logic.

  • Inconsistent RAID configurations: All RAID members must define the same raid group id and match in level and layout. Mismatches can silently fail or create invalid arrays.

8 Compatibility between AutoYaST and Agama profiles

AutoYaST has long been the standard for unattended and automated installations in SUSE Linux Enterprise Server systems. With the advent of the Agama installer, a new approach to system configuration and deployment has emerged—designed to be modular, declarative, and extensible using modern formats and APIs.

This section provides a detailed comparative view of the configuration models in AutoYaST and Agama, highlighting conceptual differences and offering practical guidance for transitioning to the Agama profile format. The goal is to equip experienced AutoYaST users with a clear roadmap for migrating existing profiles to the new Agama schema.

Where applicable, compatibility matrices are provided to indicate which AutoYaST modules and fields are currently supported, planned, undecided, or explicitly unsupported in Agama. These mappings are based on the upstream reference maintained by the Agama project.

8.1 Conceptual differences

This table highlights the fundamental differences in design philosophy and approach between AutoYaST and Agama.

Table 1: AutoYaST vs Agama design comparison
AutoYaSTAgama
XML-based, verbose syntaxYAML/JSON-based, declarative syntax
Feature-rich and legacy-compatibleMinimalist and cloud-native
Granular configuration of every detailRelies on sane defaults and abstraction
Imperative and monolithic structureComposable and modular design
Tightly coupled with YaST modulesEngineered independently with API support

8.2 Mapping AutoYaST sections to Agama schema

This section provides a detailed comparison and translation map between the major sections and modules of AutoYaST and their equivalents (or lack thereof) in the Agama profile schema. Each subsection addresses a particular functional area, indicating how configuration responsibilities are split or restructured in Agama, and clearly states where support is partial, planned, or unavailable.

Note
Note: Granular support status for AutoYaST elements

For a more granular information on the compatibility and support status for AutoYaST elements in Agama profiles as compared to what is presented here, refer to the upstream documentation https://agama-project.github.io/docs/user/autoyast/reference.

8.2.1 System identity and localization

This section covers the basic configuration for setting the system's hostname, language, keyboard layout, timezone, and the installed product identity. These are foundational parameters during the installation and are typically mapped one-to-one between AutoYaST and Agama.

Table 2: System identity and localization mapping
AutoYaST elementAgama fieldSupport statusComment
hostnamehostname.static / hostname.transientFully supportedAgama distinguishes static and transient hostnames.
languagelocalization.languageFully supportedUses standard locale codes (for example, en_US.UTF-8).
keyboardlocalization.keyboardFully supportedSet using layout ID (for example, us, de).
timezonelocalization.timezoneFully supportedTimezone IDs follow the standard timezone database names (for example, Europe/Berlin).
product / baseproduct.idFully supportedMatches product identifiers from the system's installed products metadata.
product / registerproduct.registrationCode, product.registrationEmail, product.registrationUrlFully supportedUsed for SUSEConnect-based registration. Add-ons can be declared under product.addons.

8.2.2 User management and authentication

Table 3: User and authentication mappings
AutoYaST elementSupport statusAgama fieldComment
/root/passwordFully supportedroot.passwordCan be plain text or hashed using supported schemes
/root/hashed_passwordFully supportedroot.hashedPassword = trueIndicates password is hashed
/root/ssh_authorized_keysFully supportedroot.sshPublicKeySingle key string; no support for multiple entries
/users/userFully supporteduserOnly one non-root user supported directly
/users/user/encryptedFully supporteduser.hashedPasswordSame semantics as root
/users/user/passwordFully supporteduser.passwordPlain or hashed password
/users/user/usernameFully supporteduser.userNameLogin name
/users/user/fullnameFully supporteduser.fullNameHuman-readable full name
/users/user/autologinFully supporteduser.autologinPrimarily used in desktop environments
/users/user/uid, gid, shell, homeNot supportedAgama does not currently support these fine-grained user parameters

8.2.3 Network configuration

This section details how network settings are defined in AutoYaST and Agama, covering interface setup, DHCP/static addressing, bonding, bridging, and other advanced networking configurations.

Table 4: Network configuration mapping
AutoYaST elementAgama fieldSupport statusComment
network/confignetwork.interfacesFully supportedSupports configuring individual interfaces with static or DHCP settings.
network/dnsnetwork.dnsFully supportedIncludes configuration of nameservers and search domains.
network/routingnetwork.routesFully supportedStatic route configuration is supported per interface.
network/hostnamehostnameFully supportedSystem hostname can be set independently of network block.
network/bridgenetwork.interfaces[].type: bridgeFully supportedBridge devices are supported using dedicated interface types.
network/bondingnetwork.interfaces[].type: bondFully supportedBonding configuration supports mode, primary interface, and slaves.
network/ieee8021xnetwork.interfaces[].ieee8021xPartially supportedSupports basic 802.1x authentication with identity, password, and method. Certificate support is limited.
network/proxyNot supportedNo native proxy configuration support in Agama. Should be handled post-install.

8.2.4 Storage and partitioning

This section compares the storage configuration capabilities of AutoYaST and Agama. It covers traditional partitions, logical volumes, filesystems, encryption, RAID, and other storage-specific aspects of system setup.

Table 5: Storage configuration mapping
AutoYaST elementAgama fieldSupport statusComment
partitioningstorage.devices[].partitionsFully supportedTraditional partitioning with labels, mount points, and formats are fully supported.
filesystemsstorage.devices[].partitions[].filesystemFully supportedCommon filesystems such as ext4, xfs, and btrfs are supported with mount and format options.
lvmstorage.devices[].partitions[].lvmFully supportedVolume groups and logical volumes are fully supported using declarative syntax.
raidstorage.devices[].partitions[].raidFully supportedSoftware RAID levels (0, 1, 5, etc.) are supported including metadata and spare settings.
btrfsstorage.devices[].partitions[].btrfsFully supportedSubvolumes, compression, and btrfs-specific mount options are available.
encryptionstorage.devices[].partitions[].luksFully supportedSupports LUKS encryption with passphrase, key file, and reuse options.
reuse/initializestorage.devices[].partitions[].reformat / preserveFully supportedReusing existing devices or forcing format is declaratively specified.
bootloader-locationNot supportedInstallation location of the bootloader is not configurable via storage profile.
partition-id typestorage.devices[].partitions[].typeFully supportedAllows specifying Linux native, EFI, swap, BIOS boot partitions, etc.
partition flagsstorage.devices[].partitions[].flagsFully supportedSupports marking partitions as bootable, ESP, hidden, etc.
complex criteria (e.g., by-id)storage.devices[].matchFully supportedDevices can be selected using labels, device paths, UUIDs, or custom match rules.

8.2.5 Software selection and patterns

This section maps how software selection is handled in AutoYaST and Agama, including individual package installation and pattern-based selections.

Table 6: Software and pattern mapping between AutoYaST and Agama
AutoYaST elementAgama fieldSupport statusComment
/autoinst/software/patternssoftware.patternsFully supportedPattern selection is supported directly via a list of strings.
/autoinst/software/packagessoftware.packagesFully supportedIndividual package names can be specified as strings.
/autoinst/software/remove-packagesNot supportedNo mechanism currently exists in Agama to specify packages for removal.
/autoinst/software/do_online_updateNot supportedAgama does not support configuring online updates during installation.

8.2.6 Bootloader settings

This section maps bootloader configuration options between AutoYaST and Agama profiles.

Table 7: Bootloader configuration mapping
AutoYaST elementAgama fieldSupport statusComment
bootloader—timeoutbootloader.timeoutFully supportedSets boot menu timeout before booting default entry.
bootloader—kernel_parametersbootloader.extraKernelParamsFully supportedAdditional kernel command line parameters.
bootloader—flag (for example, no_timeout)bootloader.stopOnBootMenuFully supportedControls whether the bootloader stops on the boot menu.
bootloader—locationNot supportedAgama currently does not support choosing GRUB installation location.
bootloader—gfxmode / themeNot supportedGraphical bootloader themes and resolutions are not yet configurable.

8.2.7 Security, certificates, and registration

This section compares how AutoYaST and Agama handle security settings, certificate deployment, and system registration during installation.

Table 8: Security and registration element mapping
AutoYaST elementAgama fieldSupport statusComment
security/sshdsecurity.ssh.enableFully supportedEnables or disables the SSH service.
security/certificatessecurity.trustedCertificatesFully supportedSupports placement of trusted root certificates in /etc/pki/trust/anchors.
security/ssh_import_authorized_keysroot.authorizedKeys / user.authorizedKeysFully supportedSSH public keys can be configured per user for key-based authentication.
register / suse_registerproduct.registrationFully supportedHandles system registration to SUSE Customer Center (SCC) or RMT.
security/selinuxNot supportedAgama currently does not offer SELinux configuration; SUSE systems use AppArmor by default.

8.2.8 Pre-install, post-install, and init scripts

This section maps the script execution phases between AutoYaST and Agama profiles.

Table 9: Script phases in AutoYaST vs. Agama
AutoYaST elementAgama fieldSupport statusComment
pre-scriptsscripts.preFully supportedRuns before installation begins.
postpartitioning-scriptsscripts.postPartitioningFully supportedExecuted immediately after disk partitioning.
post-scriptsscripts.postFully supportedRuns after installation finishes, with optional chroot control.
init-scriptsscripts.initFully supportedExecutes on first boot of the target system.

8.2.9 File deployment and customization

This section compares how custom files can be deployed during installation using AutoYaST and Agama profiles.

Table 10: Comparison of file deployment elements
AutoYaST elementAgama fieldSupport statusComment
files files Fully supportedSupports deployment of custom files with content, permissions, and ownership.
sysconfig Not supportedEnvironment-specific configuration via sysconfig is not directly handled in Agama.
etc Not supportedConfiguration drop-ins for /etc are not explicitly mapped in Agama.

8.2.10 Miscellaneous hardware-specific sections

This section covers specialized hardware-related configuration elements from AutoYaST and their equivalents (or lack thereof) in Agama.

Table 11: Hardware-specific configuration mapping
AutoYaST elementAgama fieldSupport statusComment
dasddasdFully supportedRequired for IBM Z (s390x) environments. Allows activation and formatting of DASD devices.
iscsiiscsiFully supportedSupports target discovery, authentication, and login configuration for iSCSI volumes.
ziplNot supportedBootloader configuration on s390x is partially handled by other fields like bootloader but no direct equivalent for zipl.
kdumpNot supportedAgama does not currently support configuring kdump crash kernels.
udevNot supportedCustom udev rules are not handled in Agama. Can be added post-install via scripts.

8.3 Unsupported AutoYaST profile elements in Agama

The following table lists AutoYaST profile sections that are currently not supported by Agama. These modules either have no equivalent functionality in Agama, are considered legacy or niche, or are planned for future implementation. This list is essential for users migrating from AutoYaST to avoid misconfiguration or unmet expectations.

Table 12: Unsupported AutoYaST modules in Agama
AutoYaST elementSupport statusComment
audit-lafNot supportedNot planned; used for audit logging configuration.
auth-clientNot supportedNo direct equivalent; should be handled post-install.
clientconfigNot supportedCustom YaST client settings not exposed in Agama.
configuration_managementNot supportedNo built-in support for Puppet, Chef, SaltStack, etc.
cronNot supportedScheduling tasks must be configured after installation.
deploy_imageNot supportedImage deployment not in scope for Agama profiles.
dhcp-serverNot supportedService configuration is beyond the profile’s scope.
dns-serverNot supportedNo direct DNS service setup support in Agama.
fcoe-clientNot supportedFCoE setup must be done manually or via other tools.
firewallNot supportedFirewall configuration is not managed by Agama.
firstbootNot supportedNo support for post-install first boot workflows.
ftp-serverNot supportedNo FTP service configuration support.
generalNot supportedLegacy catch-all section no longer used.
groupsNot supportedGroup creation must be done via post-install scripts.
hostNot supportedDeprecated; handled through hostname and networking.
http-serverNot supportedNo direct Apache/lighttpd setup supported.
kdumpSupport plannedNot yet implemented but on roadmap.
mailNot supportedNo MTA/MUA configuration support.
nfsNot supportedClient NFS mounts must be configured later.
nfs_serverNot supportedNFS server setup is out of scope.
nisNot supportedNIS authentication not available.
nis_serverNot supportedNo equivalent configuration for NIS server.
ntp-clientNot supportedTime sync must be managed post-install.
printerNot supportedNo CUPS or printer configuration support.
proxyNot supportedProxy settings must be applied via scripts or after deployment.
reportNot supportedInstall-time reporting is not implemented.
samba-clientNot supportedSamba integration must be manually configured.
soundNot supportedNo sound system setup.
squidNot supportedProxy server setup not applicable to installation profiles.
ssh_importNot supportedSSH key import handled differently in Agama.
sysconfigNot supportedLow-level sysconfig modifications not available.
tftp-serverNot supportedService configurations are expected post-install.
udevNot supportedCustom udev rules are not supported declaratively.
upgradeNot supportedIn-place upgrades are not part of the installer’s job.
usersDefaultsNot supportedNo support for user templates or defaults.

9 For more information

For more information on Agama and automated installation, refer to the following resources:

Warning
Warning: Use upstream information with caution

The upstream resources listed below may contain code or information not covered under the terms of service by SUSE. Use them with caution only as a reference for clarity and inspiration.

  • Agama user documentation: Organizes information by user perspective and covers a wide range of topics, including interactive installation, unattended installation, AutoYaST support, boot options, URLs, command-line reference, and remote access.

    • Agama boot options: Explains the kernel boot parameters that can be used to influence the Agama installation process, including how to specify the URL for an unattended installation profile using inst.auto. It also mentions other useful options like inst.info, inst.register_url, inst.install_url and inst.finish.

    • Agama storage configuration: A deep dive into storage configuration of target deployments using Agama. Essential for users with complex storage devices and partitions.

    • Agama AutoYaST compatibility reference: Essential for users migrating from AutoYaST or planning to reuse AutoYaST profiles. It details the support status of various AutoYaST profile sections and elements within Agama.

    • Agama CLI reference: A complete list of all the Agama commands.

  • Agama project on GitHub: Contains source code for the Agama installer, which you can use to deep dive into the installer's internals.