x86_64

q35, OVMF, efi or bios for users for contributors

x86_64 guests run on QEMU's q35 machine with -cpu max, under KVM with four vCPUs on a PC and emulated with one elsewhere; every system in the data has an x86_64 build, booting OVMF (efi) or QEMU's BIOS (bios), and only here do the Ubuntu Core +tpm systems boot with Secure Boot and a TPM.

On the map: architectures

▶ Watch this deck — 8 scenes, ~6 min

Worth seeing first

01 Where image-garden is most at home

X86_64 an x86_64 host, such as your PC README: tier 1, production-ready, well tested guests run at native speed 61 of 61 system names have an x86_64 build $ image-garden make ubuntu-cloud-24.04.x86_64.run the running example this deck machine and CPU efi or bios the systems snap, container worth knowing
An x86_64 host, which the README ranks tier 1 with guests at native speed; all 61 system names in the data have an x86_64 build; image-garden make ubuntu-cloud-24.04.x86_64.run is the running example; the deck covers the machine and CPU, efi or bios, the systems, the snap and container, and what is worth knowing

x86_64 is the tier 1 host and the widest column of the support matrix: every system name has an x86_64 build. image-garden make ubuntu-cloud-24.04.x86_64.run is this map's running example.

Most of the time you'll run image-garden on a PC, and that's where it's most at home. The README ranks an x86_64 host tier one: production-ready, well tested, with guests running at native speed. It's also where the choice is widest. Every system name in the data has an x86_64 build, and a few exist only here. ubuntu-cloud-24.04.x86_64, the system this map follows, is one of them. This deck is the one place for running x86_64 guests: the machine and its CPU, how fast it runs, the two ways to boot, the systems, where QEMU comes from, and what's worth knowing first.

Details and sources

Details

  • The README's host tiers: x86\_64 is tier 1, "Production-ready", "Native execution", 4 default vCPUs, "Full support, well-tested" (README.md:384-396). The table is about the host; guests of another architecture are emulated.
  • Every one of the 61 cloud system names has an x86\_64 build (counted at the pinned commit), and 13 Ubuntu Core systems are x86\_64 ones.
  • What the architectures share (-accel help, the vCPU rule) is in six architectures; this deck says what is particular to x86\_64.

for contributors

In the code

02 q35, CPU max and KVM

Q35, CPU MAX AND KVM qemu-system-x86_64 -machine q35,accel=… a modern PC chipset -cpu max -smp … every feature the accelerator offers on an x86_64 host accel=kvm:tcg -smp 4 your own processor, near full speed on an Arm host accel=tcg -smp 1 emulated, many times slower -m 2048 two gigabytes either way $ QEMU_SMP_OPTION="-smp 8" QEMU_MEM_OPTION="-m 4096" ./ubuntu-cloud-24.04.x86_64.run
ubuntu-cloud-24.04.x86_64.run, in short: qemu-system-x86_64 -machine q35 with the accelerator, -cpu max, -smp and -m 2048. On an x86_64 host it uses accel=kvm:tcg and -smp 4 and runs on your own processor; on an Arm host accel=tcg and -smp 1, emulated and many times slower. QEMU_SMP_OPTION and QEMU_MEM_OPTION change a single run

qemu-system-x86_64 -machine q35,accel=kvm:tcg -cpu max, -smp 4 on an x86_64 host and -smp 1 elsewhere, -m 2048. QEMU_SMP_OPTION and QEMU_MEM_OPTION override them for one run.

Make the .run script and look inside. QEMU's x86 emulator starts a q35 machine, a modern PC chipset, with the CPU model called max: every feature the accelerator can offer. On a PC, the script finds KVM and asks for kvm:tcg, so the guest runs on your own processor at nearly full speed, with four CPUs, because x86_64 is your host's architecture. Build the same system on an Arm host and it's emulated with TCG, many times slower, with one CPU. Memory is two gigabytes either way. QEMU_SMP_OPTION and QEMU_MEM_OPTION change both for a single run.

Details and sources

Details

  • The .run script runs -accel help when it starts and uses ,accel=kvm:tcg when kvm is listed, else ,accel=tcg; the host's own architecture gets 4 vCPUs, every other one 1 (six architectures).
  • Memory defaults to 2048 MiB. QEMU_SMP_OPTION and QEMU_MEM_OPTION from the environment replace the defaults for one run; see the .run script.
  • The -cpu model is written into the .run script when make creates it; it is not a run-time variable.
  • "q35 is a modern PC chipset" and "max offers every feature the accelerator can" are QEMU's documentation (derived): under KVM max passes through what the host CPU supports, under TCG it is everything QEMU emulates.

for contributors

In the code

03 Two ways to boot, and Secure Boot

EFI OR BIOS efi most systems ubuntu-cloud-24.04.x86_64.efi-code.qcow2 OVMF code ubuntu-cloud-24.04.x86_64.efi-vars.qcow2 its variables bios six systems QEMU's own BIOS, no firmware files amazonlinux-cloud-2 centos-cloud-9 -10 oracle-cloud-7 -8 -9 OVMF comes from the ovmf package the snap's qemu-x86-64 GARDEN_X86_64_PREFIX only on x86_64: Secure Boot, for the four +tpm systems OVMF_CODE_4M.secboot.fd + OVMF_VARS_4M.ms.fd · q35,smm=on · swtpm
efi, for most systems, boots OVMF from the system's own copies of the firmware code and variables; bios, for six systems (amazonlinux-cloud-2, centos-cloud-9 and 10, oracle-cloud-7, 8 and 9), boots QEMU's own BIOS with no firmware files. OVMF comes from the ovmf package, the snap's qemu-x86-64 component or GARDEN_X86_64_PREFIX. Only the +tpm systems get the Secure Boot pair on q35,smm=on with swtpm

Most systems boot efi, OVMF from per-system copies; six boot bios, QEMU's own BIOS. The +tpm systems get the Secure Boot pair, OVMF_CODE_4M.secboot.fd and OVMF_VARS_4M.ms.fd, on q35,smm=on.

x86_64 is the one architecture with a choice of boot. Most systems boot efi: they start OVMF, the PC build of EDK2, from their own copies of the firmware code and variables. Six boot bios instead, Amazon Linux 2, CentOS 9 and 10, and Oracle Linux 7, 8 and 9, and boot QEMU's own BIOS with no firmware files at all. OVMF comes from your distribution's ovmf package, from the snap's x86_64 component, or from a QEMU you built. And only x86_64 has Secure Boot: the Ubuntu Core +tpm systems boot OVMF's Secure Boot build, with Microsoft's keys enrolled and an emulated TPM.

Details and sources

Details

  • The six bios systems: amazonlinux-cloud-2, centos-cloud-9, centos-cloud-10, oracle-cloud-7, oracle-cloud-8 and oracle-cloud-9, all on x86\_64; their aarch64 builds, where they exist, boot efi. A bios system has no firmware files and no firmware option; the snap's component carries bios-256k.bin, the BIOS QEMU's PC machines load by default (snap/snapcraft.yaml:395-401; what QEMU loads is derived).
  • An efi system gets its own X.efi-code.qcow2 and X.efi-vars.qcow2, copied from the first OVMF build found: the ovmf package's paths (Debian, Ubuntu, Arch, openSUSE), the snap's qemu-x86-64 component, then $GARDEN_X86_64_PREFIX/share/qemu/. The whole story is in UEFI firmware per system.
  • Secure Boot needs OVMF_CODE_4M.secboot.fd and OVMF_VARS_4M.ms.fd from the same build (Ubuntu's ovmf package, or the snap's component), for the four +tpm systems only; see Secure Boot and TPM.

for contributors

In the code

04 Every system has an x86_64 build

THE SYSTEMS 61 of 61 cloud system names + 13 Ubuntu Core systems only on x86_64 archlinux-cloud · oracle-cloud-7 ubuntu-cloud-16.10 … 24.10, 13 interims apt from old-releases.ubuntu.com ubuntu-core-16 · -18 · -20 the four +tpm systems $ image-garden make list-systems | grep 'x86_64$'
All 61 system names in the data have an x86_64 build, and Ubuntu Core adds 13. Only on x86_64: archlinux-cloud and oracle-cloud-7, the 13 end-of-life Ubuntu interims whose apt uses old-releases.ubuntu.com, ubuntu-core-16, 18 and 20, and the four +tpm systems. image-garden make list-systems, filtered to the lines ending in x86_64, lists them

61 cloud systems and 13 Ubuntu Core systems. Only on x86_64: archlinux-cloud, oracle-cloud-7, the 13 end-of-life Ubuntu interims, ubuntu-core-16, -18, -20 and the four +tpm systems.

Which systems can you run here? On x86_64, the short answer is all of them. Each of the sixty-one cloud system names has an x86_64 build, and Ubuntu Core adds thirteen more. Some exist nowhere else. Arch Linux and Oracle Linux 7 are x86_64 only, and so are the thirteen Ubuntu interim releases past their end of life, which fetch their packages from the old releases archive. Ubuntu Core 16, 18 and 20 have no Arm image, and the four +tpm systems are made for x86_64 alone. To see them, run image-garden make list-systems, and keep the lines that end in x86_64.

Details and sources

Details

  • 61 cloud system names, each with an .x86_64 build (counted at the pinned commit), and 13 Ubuntu Core systems; the full table is in the support matrix and in this deck's reference.
  • x86\_64 only: archlinux-cloud, oracle-cloud-7, and the 13 end-of-life interims 16.10 to 24.10, "x86\_64, fetched from archived release URLs", whose apt uses old-releases.ubuntu.com (README.md:684-697); Ubuntu Core 16, 18 and 20 and the four +tpm systems (README.md:699-718).
  • image-garden make list-systems prints every system, one per line; the grep is ordinary shell. image-garden make all builds every system of your host's architecture.

for contributors

In the code

05 The snap, the container or your distribution

WHERE QEMU COMES FROM the snap component qemu-x86-64: installed by itself on a PC $ snap install image-garden+qemu-x86-64 without it: It seems that the component with QEMU x86-64 … the container QEMU_TARGET_LIST=x86_64-softmmu,… apt install … ovmf swtpm … images for x86_64 and aarch64 hosts a distribution Ubuntu: qemu-system-x86 ovmf, and swtpm for +tpm
The snap: the qemu-x86-64 component, installed by itself on an x86_64 host; elsewhere snap install image-garden+qemu-x86-64, and without it the stub says the component with QEMU x86-64 is not installed. The container: QEMU built with x86_64-softmmu plus Ubuntu's ovmf and swtpm packages, published for x86_64 and aarch64 hosts. Ubuntu: qemu-system-x86 and ovmf, plus swtpm for the +tpm systems

Snap: the qemu-x86-64 component, installed on x86_64 hosts by the install hook. Container: x86_64-softmmu plus the ovmf package. Ubuntu: qemu-system-x86 and ovmf, and swtpm for the +tpm systems.

The emulator and its firmware can come from three places. The snap keeps them in a component called qemu-x86-64, with dashes, and installs it by itself on a PC. On an Arm host you add it with snap install image-garden+qemu-x86-64; until you do, the snap's stand-in for QEMU shows a message with that command. The container builds QEMU with x86_64 among its targets, adds Ubuntu's ovmf package for Secure Boot, and is published for x86_64 and aarch64 hosts. On a distribution, install its x86 QEMU and OVMF: on Ubuntu, that's the packages qemu-system-x86 and ovmf. The +tpm systems also need swtpm, the TPM emulator.

Details and sources

Details

  • The snap installs the component for the host's architecture when it is installed and refreshed, so qemu-x86-64 on an x86\_64 host; a snap installed from a file installs no component (snap/hooks/install:6-13, snap/hooks/post-refresh:9-28). The component carries "the 64-bit x86 system emulator (QEMU) as well as the corresponding EFI firmware (EDK2) and the Secure Boot EFI firmware of Ubuntu (OVMF)" (snap/snapcraft.yaml:59-66).
  • Without it, QEMU's stand-in shows "It seems that the component with QEMU x86-64 is not installed" and snap install image-garden+qemu-x86-64 (qemu-stubs/qemu-system-x86_64:9-31), and making an efi system stops with "install qemu-x86-64 component to use x86\_64 emulation".
  • The container builds x86_64-softmmu among six targets (Dockerfile:33), installs ovmf and swtpm (Dockerfile:78-91) and points GARDEN_X86_64_PREFIX at its QEMU's firmware (Dockerfile:98-102). It is published for x86\_64 and aarch64 hosts (.gitlab-ci.yml:1238-1276).
  • On Ubuntu: qemu-system-x86, ovmf, and swtpm for the +tpm systems, with qemu-utils and xorriso for any system. Distribution packages may be older than the upstream release (the maintainer's statement).

for contributors

In the code

06 Inside: one makefile, two rule sets for contributors

INSIDE mk/010-qemu-x86_64.mk QEMU_SYSTEM_X86_64_MACHINE = q35 QEMU_CPU_X86_64 ?= max QEMU_SMP_X86_64 = 1 …_EFI_CMDLINE: two pflash drives …_BIOS_CMDLINE: no firmware …_RUN_COMMAND_WITH_TPM: swtpm Boot=efi or bios rulegen.py ruleset_x86_64_efi or _bios anything else: FILE: error, with the values it allows ubuntu-core-24+tpm.x86_64.run …: QEMU_SYSTEM_X86_64_MACHINE = q35,smm=on CI: the x86_64 stage, KVM runners, blocking but for end-of-life systems
mk/010-qemu-x86_64.mk sets QEMU_SYSTEM_X86_64, the q35 machine, QEMU_CPU_X86_64 ?= max and QEMU_SMP_X86_64 = 1, and holds an EFI command line with two pflash drives, a BIOS one without, and a .run emitter that can add swtpm and secure flash. rulegen.py accepts Boot=efi or bios for x86_64 and prints ruleset_x86_64_efi or _bios. The +tpm Ubuntu Core targets set q35,smm=on. The x86_64 CI stage runs on KVM runners and blocks, except for end-of-life systems

mk/010-qemu-x86_64.mk: program, machine, CPU, SMP, the EFI and BIOS command lines and the .run emitters. rulegen.py accepts Boot=efi or bios and prints ruleset_x86_64_efi or _bios.

If you maintain image-garden, here's where x86_64 lives. Its own makefile in the mk directory names the program, q35, CPU max and one CPU, and holds two QEMU command lines: one with the firmware flash drives, one without. The .run emitter for a TPM adds swtpm and secure flash. rulegen.py lets an x86_64 section say efi or bios, refuses anything else, and prints the matching rule set. The firmware search lists are defaults a project can replace. Ubuntu Core's +tpm systems set their own machine, q35 with SMM switched on. In CI, the x86_64 stage runs on KVM runners, and its failures block the pipeline, except for systems past their end of life.

Details and sources

Details

  • The makefile: program, machine, CPU, SMP and network (mk/010-qemu-x86_64.mk:3-11); QEMU_SYSTEM_X86_64_EFI_CMDLINE and _BIOS_CMDLINE for the provisioning boot (:12-39); EMIT_QEMU_SYSTEM_X86_64_EFI_RUN_COMMAND, …_WITH_TPM and …_BIOS_RUN_COMMAND for the .run script (:46-108, :218-259). The TPM variant adds EMIT_SWTPM_START and -global driver=cfi.pflash01,property=secure,value=on (:134-135).
  • BOOT_BY_ARCH and load_boot: x86\_64 takes efi or bios; a missing or other value is an error naming the section and the allowed values (rulegen.py:300-333); the rule sets (rulegen.py:593-629), chosen at rulegen.py:804-808.
  • The search lists and QEMU_CPU_X86_64 use ?=; QEMU_SYSTEM_X86_64_MACHINE and QEMU_SMP_X86_64 use =, which a target-specific assignment such as the +tpm one overrides (mk/050-ubuntu-core.mk:55).
  • CI: .systems-x86_64 runs on runners tagged linux, x86_64, kvm; the stage blocks "but for the systems past their end of life" (.gitlab-ci.yml:78-91, :624-633).

07 Worth knowing on x86_64

WORTH KNOWING EL 10 needs x86-64-v3 (Haswell) Rocky 10 and other RHEL 10 rebuilds KVM with max: your own processor QEMU_CPU_X86_64=Haswell QEMU_ACCEL_MACHINE_PROP=,accel=tcg emulated, so slow The snap writes dashes qemu-x86-64 component qemu-system-x86-64 app systems and files keep x86_64 Little-endian like aarch64 and riscv64 byte order bugs: test on s390x /dev/kvm you cannot write WARNING … /dev/kvm exists, but … $ sudo usermod -aG kvm $LOGNAME
Four things worth knowing: Rocky 10 and other RHEL 10 rebuilds need x86-64-v3, and with KVM CPU max is the host's own, so an older host sets QEMU_CPU_X86_64=Haswell with accel=tcg; the snap's names use dashes, qemu-x86-64 and qemu-system-x86-64; x86_64 is little-endian like aarch64 and riscv64, so test byte order on s390x; an unwritable /dev/kvm gets a warning and the advice to join the kvm group

EL 10 needs x86-64-v3: QEMU_CPU_X86_64=Haswell, with QEMU_ACCEL_MACHINE_PROP=,accel=tcg on an older host. The snap writes x86-64 with dashes. For a big-endian guest use s390x.

A few things catch people out here. Rocky 10 and the other rebuilds of Red Hat Enterprise Linux 10 need an x86-64-v3 processor, Haswell or newer. Under KVM, CPU max is your own processor, so an older host can't boot them: set QEMU_CPU_X86_64 to Haswell and let TCG emulate it, slowly. In the snap, names use dashes: the component is qemu-x86-64 and the app qemu-system-x86-64, while systems and files keep x86_64. x86 is little-endian, like Arm and RISC-V, so for byte order bugs, test on s390x. And if /dev/kvm isn't writable, image-garden prints a loud warning: join the kvm group.

Details and sources

Details

  • README: "Rocky 10 (and other RHEL 10 derivatives) require at least Haswell CPU (x86\_64-v3). Set QEMU_CPU_X86_64=Haswell or newer if needed" (README.md:677-681). With KVM, -cpu max offers what the host CPU has (derived), so a host without x86-64-v3 cannot give it. Under TCG, set both: image-garden make QEMU_CPU_X86_64=Haswell SYSTEM.run and run it with QEMU_ACCEL_MACHINE_PROP=,accel=tcg.
  • QEMU_CPU_X86_64 is set with ?=, so it can come from the environment as well as the make command line (mk/010-qemu-x86_64.mk:6); it is written into the .run script when make creates it, so remake the script after changing it. QEMU_ACCEL_MACHINE_PROP is read when the script runs (mk/010-qemu-x86_64.mk:72).
  • Snap app names cannot contain underscores, so the app is qemu-system-x86-64 and runs qemu-system-x86_64 (snap/snapcraft.yaml:149-152, mk/010-qemu-x86_64.mk:3-4).
  • x86\_64, aarch64 and riscv64 Linux are little-endian and s390x is big-endian (derived, general knowledge); image-garden's own comment calls the ppc64 systems little-endian (mk/000-garden.mk:14-16).
  • The /dev/kvm warning and its advice (image-garden:670-709) are shown in six architectures.

for contributors

In the code

  • image-garden's own CI once tested EL 10 that way, with QEMU_CPU_X86_64: Haswell and QEMU_ACCEL_MACHINE_PROP: ",accel=tcg" (commit 128bbd5, "ci: disable kvm on emulated x86_64-v3").

08 Where to go from here

ROADS x86_64 Boot types efi and bios in the rules UEFI firmware where OVMF is found Secure Boot and TPM the +tpm systems The support matrix beside the other five Snap components qemu-x86-64 The container in CI with and without KVM The .run script
Roads from x86_64: boot types and UEFI firmware, Secure Boot and the TPM, the support matrix, snap components, the container in CI, and the .run script

Next: boot types, UEFI firmware, Secure Boot and the TPM, the support matrix, snap components, the container in CI and the .run script.

So x86_64 is a q35 machine with CPU max, running under KVM on your PC, booting OVMF or QEMU's BIOS, with every system in the data. From here, the boot deck shows what efi and bios change in the rules, and the firmware deck where OVMF is found. The Secure Boot deck covers the +tpm systems, and the support matrix sets x86_64 beside the other five. The snap components deck explains qemu-x86-64, the container in CI deck covers runners with and without KVM, and the run script deck every knob of a boot.

Details and sources

Read more

Basis of the statements on this page

Read in the README, mk/010-qemu-x86_64.mk, mk/010-qemu.mk, mk/000-garden.mk, mk/050-ubuntu-core.mk, rulegen.py, data/*.ini, snap/snapcraft.yaml, snap/hooks/install, qemu-stubs/qemu-system-x86_64, the Dockerfile and .gitlab-ci.yml of image-garden at the commit in garden.commit ("code"). The system counts were taken from the INI files at that commit. What q35, -cpu max and the BIOS do inside QEMU, and byte order, are derived from QEMU's documentation and general knowledge. Nothing was run for this page.

x86_64 at a glance

FactValue
QEMU programqemu-system-x86_64; in the snap the image-garden.qemu-system-x86-64 app
Machineq35; q35,smm=on for the +tpm systems
CPUmax
Acceleratorkvm:tcg when QEMU lists KVM, else tcg
vCPUs4 on an x86\_64 host, 1 elsewhere
Memory-m 2048
Boot typesefi and bios
Firmware (efi)OVMF, copied to efi-code.x86_64.img and efi-vars.x86_64.img, then per system X.efi-code.qcow2 and X.efi-vars.qcow2
Firmware (Secure Boot)OVMF_CODE_4M.secboot.fd and OVMF_VARS_4M.ms.fd, copied to efi-secboot-code.x86_64.img and efi-secboot-vars.x86_64.img
Firmware (bios)none; QEMU's own BIOS
Network-netdev user, virtio-net-pci, -smbios type=41
Snap componentqemu-x86-64, installed by the snap on x86\_64 hosts
ContainerQEMU with x86_64-softmmu, ovmf, swtpm; images for x86\_64 and aarch64 hosts
Ubuntu packagesqemu-system-x86, ovmf, and swtpm for +tpm
Host tier1: production-ready
Byte orderlittle-endian (derived)

Systems

All 61 cloud system names have an x86\_64 build, so NAME.x86_64 exists for every row of the support matrix, plus 13 Ubuntu Core systems.

BootSystems
biosamazonlinux-cloud-2, centos-cloud-9, centos-cloud-10, oracle-cloud-7, oracle-cloud-8, oracle-cloud-9
efithe other 55 cloud systems, and ubuntu-core-16, -18, -20, -22, -24, -26 and -22+dangerous, -24+dangerous, -26+dangerous
efi with Secure Boot and a TPMubuntu-core-24+tpm, -24+dangerous+tpm, -26+tpm, -26+dangerous+tpm

Only on x86\_64: archlinux-cloud, oracle-cloud-7, ubuntu-cloud-16.10, 17.04, 17.10, 18.10, 19.04, 19.10, 20.10, 21.04, 21.10, 22.10, 23.04, 23.10, 24.10, ubuntu-core-16, -18, -20 and the four +tpm systems.

Run-time knobs

VariableEffect
QEMU_ACCEL_MACHINE_PROPreplaces ,accel=kvm:tcg, such as ,accel=tcg
QEMU_SMP_OPTION, QEMU_MEM_OPTIONreplace -smp N and -m 2048
QEMU_BOOT_FIRMWARE_OPTIONreplaces the two pflash drives of an efi system
QEMU_CPU_X86_64make variable or environment: the -cpu model written into a new .run script, Haswell for EL 10 under TCG

See the .run script for every run-time variable.

for contributors

Where it is set

FactSource
Program, machine, CPU, SMP, networkmk/010-qemu-x86_64.mk:3-11
Accelerator testmk/010-qemu-x86_64.mk:63
Native vCPU count, memorymk/010-qemu.mk:5-12
Boot types allowedrulegen.py:302-309
OVMF lists and copiesmk/010-qemu-x86_64.mk:260-329
q35,smm=on for +tpmmk/050-ubuntu-core.mk:55
Snap componentsnap/snapcraft.yaml:59-66, snap/hooks/install:6-13
ContainerDockerfile:33, Dockerfile:78-102, .gitlab-ci.yml:1238-1276
Host tierREADME.md:384-396
Make variableEffect
QEMU_SMP_X86_64the default -smp
QEMU_SYSTEM_X86_64 (?=)the QEMU program
QEMU_EDK2_CODE_X86_64, QEMU_EDK2_VARS_X86_64 (?=)the OVMF search lists
QEMU_EDK2_SECBOOT_CODE_X86_64, QEMU_EDK2_SECBOOT_VARS_X86_64 (?=)the Secure Boot search lists
GARDEN_X86_64_PREFIX (environment)appends a self-built QEMU's share/qemu firmware

See six architectures for how the defaults are set.

Roads from here

SYSTEMS · distributions

UBUNTU CORE · all snaps

ARCHITECTURES · machines and firmware

RUNTIME · make rules and the CLI

SNAP · snap-only features

CONTAINER · OCI image