Update docker build

docker/Dockerfile-focal

@@ -1,10 +1,24 @@
 # -*- mode: dockerfile -*-
 
-FROM nvidia/cuda:11.4.3-devel-ubuntu20.04
+FROM nvidia/cuda:12.4.1-devel-ubuntu20.04
+
+ARG TARGETPLATFORM
+RUN echo "Building image for $TARGETPLATFORM"
 
 ARG PYTHON_VERSION=3.8
 ENV DEBIAN_FRONTEND=noninteractive
-RUN apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/3bf863cc.pub
+
+RUN apt-get update && \
+    apt-get install -yq wget
+
+RUN case ${TARGETPLATFORM} in \
+    "linux/amd64")  CUDA_ARCH=x86_64  ;; \
+    "linux/x86_64") CUDA_ARCH=x86_64  ;; \
+    "linux/arm64")  CUDA_ARCH=arm64 ;; \
+    esac && \
+    wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/${CUDA_ARCH}/cuda-keyring_1.0-1_all.deb
+
+RUN dpkg -i cuda-keyring_1.0-1_all.deb
 
 RUN apt-get update && apt-get install -yq \
         bison \
@@ -19,11 +33,16 @@ RUN apt-get update && apt-get install -yq \
 
 WORKDIR /opt/conda_setup
 
-RUN curl -o miniconda.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh && \
-     chmod +x miniconda.sh && \
-     ./miniconda.sh -b -p /opt/conda && \
-     /opt/conda/bin/conda install -y python=$PYTHON_VERSION && \
-     /opt/conda/bin/conda clean -ya
+RUN case ${TARGETPLATFORM} in \
+    "linux/amd64")  MINI_ARCH=x86_64  ;; \
+    "linux/x86_64") MINI_ARCH=x86_64  ;; \
+    "linux/arm64")  MINI_ARCH=aarch64 ;; \
+    esac && \
+    curl -o miniconda.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-${MINI_ARCH}.sh && \
+    chmod +x miniconda.sh && \
+    ./miniconda.sh -b -p /opt/conda && \
+    /opt/conda/bin/conda install -y python=$PYTHON_VERSION && \
+    /opt/conda/bin/conda clean -ya
 ENV PATH /opt/conda/bin:$PATH
 
 RUN python -m pip install --upgrade pip ipython ipdb
@@ -36,12 +55,4 @@ RUN pip install '.[all]'
 
 WORKDIR /workspace
 
-CMD ["/bin/bash"]
-
-
-# Docker commands:
-#   docker rm nle -v
-#   docker build -t nle -f docker/Dockerfile-focal .
-#   docker run --gpus all --rm --name nle nle
-# or
-#   docker run --gpus all -it --entrypoint /bin/bash nle
+CMD ["/bin/bash"]

docker/Dockerfile-jammy

@@ -0,0 +1,58 @@
+# -*- mode: dockerfile -*-
+
+FROM nvidia/cuda:12.4.1-devel-ubuntu22.04
+
+ARG TARGETPLATFORM
+RUN echo "Building image for $TARGETPLATFORM"
+
+ARG PYTHON_VERSION=3.11
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && \
+    apt-get install -yq wget
+
+RUN case ${TARGETPLATFORM} in \
+    "linux/amd64")  CUDA_ARCH=x86_64  ;; \
+    "linux/x86_64") CUDA_ARCH=x86_64  ;; \
+    "linux/arm64")  CUDA_ARCH=arm64 ;; \
+    esac && \
+    wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/${CUDA_ARCH}/cuda-keyring_1.0-1_all.deb
+
+RUN dpkg -i cuda-keyring_1.0-1_all.deb
+
+RUN apt-get update && apt-get install -yq \
+        bison \
+        build-essential \
+        cmake \
+        curl \
+        flex \
+        git \
+        libbz2-dev \
+        ninja-build \
+        wget
+
+WORKDIR /opt/conda_setup
+
+RUN case ${TARGETPLATFORM} in \
+    "linux/amd64")  MINI_ARCH=x86_64  ;; \
+    "linux/x86_64") MINI_ARCH=x86_64  ;; \
+    "linux/arm64")  MINI_ARCH=aarch64 ;; \
+    esac && \
+    curl -o miniconda.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-${MINI_ARCH}.sh && \
+    chmod +x miniconda.sh && \
+    ./miniconda.sh -b -p /opt/conda && \
+    /opt/conda/bin/conda install -y python=$PYTHON_VERSION && \
+    /opt/conda/bin/conda clean -ya
+ENV PATH /opt/conda/bin:$PATH
+
+RUN python -m pip install --upgrade pip ipython ipdb
+
+COPY . /opt/nle/
+
+WORKDIR /opt/nle
+
+RUN pip install '.[all]'
+
+WORKDIR /workspace
+
+CMD ["/bin/bash"]

docker/README.md

@@ -1,47 +1,37 @@
 # Docker images for NLE
 
-This directory -- i.e., `docker/` -- contains some docker images that we use for
-testing both locally and in CI. They contain dependencies and a pre-built
-version of NLE.
+This directory -- i.e., `docker/` -- contains some dockerfiles to 
+create NLE images.  They are based on the NVDIA Ubuntu images and
+so include CUDA support. However, you don't need any GPUs to make
+and run containers from the images.
 
-You can try out the latest stable version in Ubuntu 18.04 by doing:
+Docker now provides multi-architecture support so whether you are
+using an x86_64, amd64 or arm64 CPU you can use the same image to 
+run an NLE container.
 
-```bash
-$ docker pull fairnle/nle:stable
-$ docker run --gpus all --rm -it fairnle/nle:stable python  # or bash
-# Then you can simply use the nle package as normal
-```
+# Building Images Locally
 
-The git repository is installed inside a conda distribution, and can be found in
-`/opt/nle` inside the images.
-
-The DockerHub repository also contains pre-built images per each released
-version of `nle`, following a specific templates:
-
-``` bash
-1.  fairnle/nle:stable
-2.  fairnle/nle:<nle-version>         # corresponds to (1), based on Ubuntu 18.04
-3.  fairnle/nle-xenial:<nle-version>  # Based on Ubuntu 16.04
-4.  fairnle/nle-focal:<nle-version>   # Based on Ubuntu 20.04
-5.  fairnle/nle:<sha>                 # bionic image built on dockerfile changes
-6.  fairnle/nle-xenial:<sha>          # xenial image built on dockerfile changes
-7.  fairnle/nle-focal:<sha>           # focal image built on dockerfile changes
-8.  fairnle/nle:dev                   # points to latest built sha
-9.  fairnle/nle-xenial:dev            # points to latest built sha
-10. fairnle/nle-focal:dev             # points to latest built sha
-```
+To build and run an image (e.g. `Dockerfile-jammy`) for your local 
+architecture do:
 
-`<nle-version>` is the latest pip version released, and follows semantic versioning (so something like `X.Y.Z`).
+```bash
+$ git clone https://github.com/heiner/nle --recursive
+$ cd nle
+$ docker build -file docker/Dockerfile-jammy . -tag nle
+$ docker run -it --gpus all --rm --name nle nle
+# or alternatively if you don't have GPUs
+$ docker run -it --name nle nle
+```
 
-# Building images locally
+# Building Multi-Architecture Images
 
-To build and run any of them (e.g. `Dockerfile-bionic`) do:
+To build an image on your machine that can be deployed on multiple
+architectures (e.g. x86_64, amd64 or arm64), use the following docker 
+command. Run it from the nle directory.
 
 ```bash
-$ git clone https://github.com/heiner/nle --recursive
-$ cd nle
-$ docker build -f docker/Dockerfile-bionic . -t nle
-$ docker run --gpus all --rm --name nle nle
-# or alternatively
-$ docker run --gpus all -it --entrypoint /bin/bash nle
+$ docker buildx build --platform linux/amd64,linux/arm64 -t nle -f docker/Dockerfile-jammy .
 ```
+
+The run instructions are as before. Docker will load the correct
+binaries for the architecture you are running the container on.