AWS GPU: Create an Image

Learn how to build a custom AMI for use with DKP

AMI images contain configuration information and software to create a specific, pre-configured, operating environment. For example, you can create an AMI image of your current computer system settings and software. The AMI image can then be replicated and distributed, creating your computer system for other users. You can use overrides files to customize some of the components installed on your machine image. For example, you could tell KIB to install the FIPS versions of the Kubernetes components.

This procedure describes how to use the Konvoy Image Builder (KIB) to create a Cluster API compliant Amazon Machine Image (AMI). KIB uses variable overrides to specify base image and container images to use in your new AMI.

In previous DKP releases, AMI images provided by the upstream CAPA project would be used if you did not specify an AMI. However, the upstream images are not recommended for production and may not always be available. Therefore, DKP now requires you to specify an AMI when creating a cluster. To create an AMI, use Konvoy Image Builder.

Prerequisites

Before you begin, you must:

Download the KIB bundle for your version of DKP prefixed with konvoy-image-bundle for your OS.
Check the Supported Infrastructure Operating Systems
Check the Supported Kubernetes Version for your Provider.
Create a working registry:
- Version 4.0 of Podman or higher for Linux. Host requirements found here: https://kind.sigs.k8s.io/docs/user/rootless/#host-requirements
- Version 20.10.0 of Docker or higher for Linux or MacOS
Ensure you have met the minimal set of permissions from the AWS Image Builder Book.
A Minimal IAM Permissions for KIB to create an Image for an AWS account using Konvoy Image Builder.

Extract KIB Bundle

If not done previously during Konvoy Image Builder download in prerequisites, extract the bundle and cd into the extracted konvoy-image-bundle-$VERSION folder. Otherwise, proceed with creating the image. The bundled version of konvoy-image contains an embedded docker image that contains all the requirements for building.

The konvoy-image binary and all supporting folders are also extracted. When run, konvoy-image bind mounts the current working directory (${PWD}) into the container to be used.

Set environment variables for AWS access. The following variables must be set using your credentials including required IAM:
CODE
```
export AWS_ACCESS_KEY_ID
export AWS_SECRET_ACCESS_KEY
export AWS_DEFAULT_REGION
```
If you have an override file to configure specific attributes of your AMI file, add it. Instructions for customizing an override file are found on this page: Image Overrides

Build the GPU Image

Using the Konvoy Image Builder, you can build an image that has support to use NVIDIA GPU hardware to support GPU workloads.

NOTE: The NVIDIA driver requires a specific Linux kernel version. Make sure that the base image for the OS version has the required kernel version.

See Supported Infrastructure Operating Systems for a list of OS versions and the corresponding kernel versions known to work with the NVIDIA driver.

If the NVIDIA runfile installer has not been downloaded, then retrieve and install the download first by running the following command. The first line in the command below downloads and installs the runfile and the second line places it in the artifacts directory (you must create an artifacts directory if you don’t already have one).

CODE

curl -O https://download.nvidia.com/XFree86/Linux-x86_64/470.82.01/NVIDIA-Linux-x86_64-470.82.01.run
mv NVIDIA-Linux-x86_64-470.82.01.run artifacts

DKP supported NVIDIA driver version is 470.x.

To build an image for use on GPU enabled hardware, perform the following steps.

In your override file, add the following to enable GPU builds. Otherwise, you can access and use the overrides in our repo or in the documentation under Nvidia GPU Override File or Offline Nvidia Override file.
1. Non-air-gapped GPU override overrides/nvidia.yaml:
  CODE
```
gpu:
  types:
    - nvidia
build_name_extra: "-nvidia"
```
2. Air-gapped GPU override overrides/offline-nvidia.yaml:
  CODE
```
# Use this file when building a machine image, not as a override secret for preprovisioned environments
nvidia_runfile_local_file: "{{ playbook_dir}}/../artifacts/{{ nvidia_runfile_installer }}"
gpu:
  types:
    - nvidia

build_name_extra: "-nvidia"
```
  NOTE: For RHEL Pre-provisioned Override Files used with KIB, see specific note for GPU.
Build your image using the build Konvoy Image Builder command, making sure to include the flag --instance-type that specifies an AWS instance that has an available GPU:
AWS Example:
CODE
```
konvoy-image build --region us-east-1 --instance-type=p2.xlarge --source-ami=ami-12345abcdef images/ami/centos-7.yaml --overrides overrides/nvidia.yaml
```
In this example, we chose an instance type with an NVIDIA GPU using the --instance-type flag, and we provided the NVIDIA overrides using the --overrides flag. See Using KIB with AWS for more information on creating an AMI.
When the Konvoy Image Builder image is complete, the custom ami id is printed and written to ./.. To use the built ami with Konvoy, specify it with the --ami flag when calling cluster create.

Additional helpful information can be found in the NVIDIA Device Plug-in for Kubernetes instructions and the Installation Guide of Supported Platforms.

Related Information:

To use a local registry even in a non-air-gapped environment, download and extract the bundle. Download the Complete DKP Air-gapped Bundle for this release (i.e. dkp-air-gapped-bundle_v2.7.0_linux_amd64.tar.gz) to load registry.
Load the Registry

Next Steps:

AWS GPU: Create the Management Cluster