### Installer Stage Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/runtime-deps-8.0-cbl-mariner2.0-amd64-Dockerfile.approved.txt

Sets up an intermediate 'installer' stage to install shadow-utils, which are needed for user management, and cleans up the package cache.

```Dockerfile
FROM base AS installer

RUN tdnf install -y \
        shadow-utils \
    && tdnf clean all
```

--------------------------------

### Final ASP.NET Composite Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-8.0-jammy-chiseled-composite-amd64-Dockerfile.approved.txt

Sets environment variables for .NET and ASP.NET versions, copies the installed runtime and symlink from the installer stage, and sets the entrypoint and default command.

```Dockerfile
# ASP.NET Composite Image
FROM $REPO:0.0.0-jammy-chiseled-amd64

ENV \
    # .NET Runtime version
    DOTNET_VERSION=0.0.0 \
    # ASP.NET Core version
    ASPNET_VERSION=0.0.0

COPY --from=installer ["/usr/share/dotnet", "/usr/share/dotnet"]
COPY --from=installer ["/dotnet-symlink", "/usr/bin"]

ENTRYPOINT ["/usr/bin/dotnet"]
CMD ["--info"]
```

--------------------------------

### Final .NET Runtime Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/runtime-8.0-cbl-mariner2.0-distroless-extra-amd64-Dockerfile.approved.txt

Copies the installed .NET runtime and the 'dotnet' symlink from the installer stage into the final distroless image. Sets the entrypoint to 'dotnet' and the default command to '--info'.

```Dockerfile
FROM $REPO:0.0.0-cbl-mariner2.0-distroless-extra-amd64

# .NET Runtime version
ENV DOTNET_VERSION=0.0.0

COPY --from=installer ["/usr/share/dotnet", "/usr/share/dotnet"]
COPY --from=installer ["/dotnet-symlink", "/usr/bin"]

ENTRYPOINT ["/usr/bin/dotnet"]
CMD ["--info"]
```

--------------------------------

### Final .NET Runtime Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/runtime-10.0-azurelinux3.0-distroless-extra-amd64-Dockerfile.approved.txt

Copies the installed .NET runtime and the symlinked dotnet executable from the installer stage into the final runtime image. Sets the entrypoint and default command.

```Dockerfile
COPY --from=installer ["/usr/share/dotnet", "/usr/share/dotnet"]
COPY --from=installer ["/dotnet-symlink", "/usr/bin"]

ENTRYPOINT ["/usr/bin/dotnet"]
CMD ["--info"]
```

--------------------------------

### Dockerfile Setup for .NET SDK

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/sdk-10.0-noble-aot-amd64-Dockerfile.approved.txt

This snippet defines the base image and installs essential development tools and libraries. It ensures a clean state by removing apt cache after installation.

```dockerfile
ARG REPO=mcr.microsoft.com/dotnet/sdk
FROM $REPO:0.0.0-noble-amd64

RUN apt-get update \
    && apt-get install -y --no-install-recommends \
        clang \
        llvm \
        zlib1g-dev \
    && rm -rf /var/lib/apt/lists/*
```

--------------------------------

### Final .NET Runtime Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/runtime-8.0-azurelinux3.0-distroless-amd64-Dockerfile.approved.txt

Copies the installed .NET runtime from the installer stage and the symlinked dotnet executable to their final locations in the distroless image. Sets the entrypoint to the dotnet executable.

```dockerfile
COPY --from=installer ["/usr/share/dotnet", "/usr/share/dotnet"]
COPY --from=installer ["/dotnet-symlink", "/usr/bin"]
```

```dockerfile
ENTRYPOINT ["/usr/bin/dotnet"]
CMD ["--info"]
```

--------------------------------

### Configure SDK Image and Install Tools

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/sdk-9.0-azurelinux3.0-arm64v8-Dockerfile.approved.txt

Sets up the final SDK image with environment variables for .NET and installs git and libgcc-atomic. It then copies the installed SDK from the installer stage.

```Dockerfile
# .NET SDK image
FROM $REPO:0.0.0-azurelinux3.0-arm64v8

ENV \
    # Do not generate certificate
    DOTNET_GENERATE_ASPNET_CERTIFICATE=false \
    # Do not show first run text
    DOTNET_NOLOGO=true \
    # SDK version
    DOTNET_SDK_VERSION=0.0.0 \
    # Enable correct mode for dotnet watch (only mode supported in a container)
    DOTNET_USE_POLLING_FILE_WATCHER=true \
    # Skip extraction of XML docs - generally not useful within an image/container - helps performance
    NUGET_XMLDOC_MODE=skip \
    # PowerShell telemetry for docker image usage
    POWERSHELL_DISTRIBUTION_CHANNEL=PSDocker-DotnetSDK-Azure-Linux-3.0-arm64

RUN tdnf install -y \
        git \
        libgcc-atomic \
        tar \
    && tdnf clean all

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]

# Trigger first run experience by running arbitrary cmd
RUN dotnet help
```

--------------------------------

### Final ASP.NET Composite Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-10.0-azurelinux3.0-distroless-composite-extra-arm64v8-Dockerfile.approved.txt

Sets environment variables for .NET and ASP.NET versions, copies the runtime from the installer stage, and configures the entrypoint and default command.

```Dockerfile
FROM $REPO:0.0.0-azurelinux3.0-distroless-extra-arm64v8

ENV \
    # .NET Runtime version
    DOTNET_VERSION=0.0.0 \
    # ASP.NET Core version
    ASPNET_VERSION=0.0.0

COPY --from=installer ["/usr/share/dotnet", "/usr/share/dotnet"]
COPY --from=installer ["/dotnet-symlink", "/usr/bin"]

ENTRYPOINT ["/usr/bin/dotnet"]
CMD ["--info"]
```

--------------------------------

### ASP.NET Composite Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-8.0-noble-chiseled-composite-extra-arm64v8-Dockerfile.approved.txt

This stage sets environment variables for the .NET and ASP.NET Core versions. It then copies the installed runtime from the 'installer' stage and makes the dotnet executable available in the system's PATH by copying it to /usr/bin. The ENTRYPOINT is set to the dotnet executable, with a default CMD to display version information.

```Dockerfile
# ASP.NET Composite Image
FROM $REPO:0.0.0-noble-chiseled-extra-arm64v8

ENV 
    # .NET Runtime version
    DOTNET_VERSION=0.0.0 
    # ASP.NET Core version
    ASPNET_VERSION=0.0.0

COPY --from=installer ["/usr/share/dotnet", "/usr/share/dotnet"]
COPY --from=installer ["/dotnet-symlink", "/usr/bin"]

ENTRYPOINT ["/usr/bin/dotnet"]
CMD ["--info"]
```

--------------------------------

### Final ASP.NET Composite Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-9.0-azurelinux3.0-distroless-composite-amd64-Dockerfile.approved.txt

Sets environment variables for .NET and ASP.NET Core versions. Copies the installed runtime and symlink from the installer stage into the final image. Sets the entrypoint to dotnet and the default command to --info.

```Dockerfile
FROM $REPO:0.0.0-azurelinux3.0-distroless-amd64

ENV \
    # .NET Runtime version
    DOTNET_VERSION=0.0.0 \
    # ASP.NET Core version
    ASPNET_VERSION=0.0.0

COPY --from=installer ["/usr/share/dotnet", "/usr/share/dotnet"]
COPY --from=installer ["/dotnet-symlink", "/usr/bin"]

ENTRYPOINT ["/usr/bin/dotnet"]
CMD ["--info"]
```

--------------------------------

### Dockerfile Setup for .NET SDK

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/sdk-9.0-azurelinux3.0-aot-amd64-Dockerfile.approved.txt

This snippet defines the base image and installs necessary build tools like build-essential and clang. It cleans up the package cache afterwards.

```docker
# syntax=docker/dockerfile:1
ARG REPO=mcr.microsoft.com/dotnet/sdk
FROM $REPO:0.0.0-azurelinux3.0-amd64

RUN tdnf install -y \
        build-essential \
        clang \
        zlib-devel \
    && tdnf clean all

```

--------------------------------

### Final Runtime Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/runtime-9.0-azurelinux3.0-distroless-arm64v8-Dockerfile.approved.txt

Copies the installed .NET runtime and the symlinked dotnet executable into the final runtime image. Sets the entrypoint and default command.

```Dockerfile
FROM $REPO:0.0.0-azurelinux3.0-distroless-arm64v8

# .NET Runtime version
ENV DOTNET_VERSION=0.0.0

COPY --from=installer ["/usr/share/dotnet", "/usr/share/dotnet"]
COPY --from=installer ["/dotnet-symlink", "/usr/bin"]

ENTRYPOINT ["/usr/bin/dotnet"]
CMD ["--info"]
```

--------------------------------

### Final ASP.NET Composite Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-10.0-alpine3.22-composite-amd64-Dockerfile.approved.txt

This stage sets the DOTNET_VERSION and ASPNET_VERSION environment variables. It then copies the installed .NET runtime from the installer stage and creates a symbolic link for the dotnet executable.

```Dockerfile
# ASP.NET Composite Image
FROM $REPO:0.0.0-alpine3.XX-amd64

ENV \
    # .NET Runtime version
    DOTNET_VERSION=0.0.0 \
    # ASP.NET Core version
    ASPNET_VERSION=0.0.0

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]
RUN ln -s /usr/share/dotnet/dotnet /usr/bin/dotnet

```

--------------------------------

### Install .NET SDK from Archive

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/sdk-10.0-alpine3.23-arm64v8-Dockerfile.approved.txt

Installs the .NET SDK by downloading a tarball, verifying its integrity using SHA512, and extracting it to the /dotnet directory. This process is part of the 'installer' build stage.

```Dockerfile
RUN dotnet_sdk_version=0.0.0 \
    && dotnet_sdk_build_version=$dotnet_sdk_version \
    && wget --header "Authorization: Bearer $ACCESSTOKEN" --header "x-ms-version: 2017-11-09" \
        https://dotnetstage.blob.core.windows.net/Sdk/$dotnet_sdk_build_version/dotnet-sdk-$dotnet_sdk_build_version-linux-musl-arm64.tar.gz \
        https://dotnetstage.blob.core.windows.net/Sdk/$dotnet_sdk_build_version/dotnet-sdk-$dotnet_sdk_build_version-linux-musl-arm64.tar.gz.sha512 \
    && echo "$(cat dotnet-sdk-$dotnet_sdk_build_version-linux-musl-arm64.tar.gz.sha512)  dotnet-sdk-$dotnet_sdk_build_version-linux-musl-arm64.tar.gz" | sha512sum -c - \
    && mkdir --parents /dotnet \
    && tar --gzip --extract --no-same-owner --file dotnet-sdk-$dotnet_sdk_build_version-linux-musl-arm64.tar.gz --directory /dotnet ./dnx ./packs ./sdk ./sdk-manifests ./templates ./LICENSE.txt ./ThirdPartyNotices.txt \
    && rm \
        dotnet-sdk-$dotnet_sdk_build_version-linux-musl-arm64.tar.gz \
        dotnet-sdk-$dotnet_sdk_build_version-linux-musl-arm64.tar.gz.sha512
```

--------------------------------

### Install System Packages and Copy SDK

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/sdk-11.0-alpine3.23-arm64v8-Dockerfile.approved.txt

Installs essential system packages like curl, git, and ICU, then copies the installed .NET SDK from the installer stage into the final image.

```Dockerfile
# .NET SDK image
FROM $REPO:0.0.0-alpine3.XX-arm64v8

RUN apk add --upgrade --no-cache \
        curl \
        git \
        icu-data-full \
        icu-libs \
        libatomic \
        tzdata

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]
```

--------------------------------

### Configure .NET SDK Environment and Install PowerShell

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/sdk-11.0-azurelinux3.0-arm64v8-Dockerfile.approved.txt

Sets environment variables for the .NET SDK, installs git and libgcc-atomic, copies the SDK from the installer stage, creates a symlink for dnx, and installs the PowerShell global tool.

```Dockerfile
# .NET SDK image
FROM $REPO:0.0.0-azurelinux3.0-arm64v8

ENV \
    # Do not generate certificate
    DOTNET_GENERATE_ASPNET_CERTIFICATE=false \
    # Do not show first run text
    DOTNET_NOLOGO=true \
    # SDK version
    DOTNET_SDK_VERSION=0.0.0 \
    # Enable correct mode for dotnet watch (only mode supported in a container)
    DOTNET_USE_POLLING_FILE_WATCHER=true \
    # Skip extraction of XML docs - generally not useful within an image/container - helps performance
    NUGET_XMLDOC_MODE=skip \
    # PowerShell telemetry for docker image usage
    POWERSHELL_DISTRIBUTION_CHANNEL=PSDocker-DotnetSDK-Azure-Linux-3.0-arm64 \
    # Workaround for https://github.com/PowerShell/PowerShell/issues/20685
    DOTNET_ROLL_FORWARD=Major

RUN tdnf install -y \
        git \
        libgcc-atomic \
        tar \
    && tdnf clean all

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]

RUN ln -s /usr/share/dotnet/dnx /usr/bin/dnx \
    # Trigger first run experience by running arbitrary cmd
    && dotnet help

# Install PowerShell global tool
RUN powershell_version=0.0.0 \
    && curl --fail --show-error --location --output PowerShell.Linux.arm64.$powershell_version.nupkg https://powershellinfraartifacts-gkhedzdeaghdezhr.z01.azurefd.net/tool/$powershell_version/PowerShell.Linux.arm64.$powershell_version.nupkg \
    && powershell_sha512='{sha512_placeholder}' \
    && echo "$powershell_sha512  PowerShell.Linux.arm64.$powershell_version.nupkg" | sha512sum -c - \
    && mkdir --parents /usr/share/powershell \
    && dotnet tool install --add-source / --tool-path /usr/share/powershell --version $powershell_version PowerShell.Linux.arm64 \
    && dotnet nuget locals all --clear \
    && rm PowerShell.Linux.arm64.$powershell_version.nupkg \
    && ln -s /usr/share/powershell/pwsh /usr/bin/pwsh \
    && chmod 755 /usr/share/powershell/pwsh \
    # To reduce image size, remove the copy nupkg that nuget keeps.
    && find /usr/share/powershell -print | grep -i '.*[.]nupkg$' | xargs rm
```

--------------------------------

### Install Base Packages and Copy SDK

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/sdk-9.0-azurelinux3.0-amd64-Dockerfile.approved.txt

Installs essential packages like git and tar, cleans up package manager cache, and copies the .NET SDK from the installer stage into the final image.

```Dockerfile
RUN tdnf install -y \
        git \
        libgcc-atomic \
        tar \
    && tdnf clean all

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]
```

--------------------------------

### Run Sample Image

Source: https://github.com/dotnet/dotnet-docker/blob/main/samples/dotnetapp/README.md

Launches a pre-built sample .NET application image from the container registry.

```console
docker run --rm mcr.microsoft.com/dotnet/samples:dotnetapp-chiseled
```

--------------------------------

### ASP.NET Core Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-10.0-noble-chiseled-arm64v8-Dockerfile.approved.txt

This section sets the ASP.NET Core version and copies the installed runtime from the installer stage into the final chiseled image.

```Dockerfile
# ASP.NET Core image
FROM $REPO:0.0.0-noble-chiseled-arm64v8

# ASP.NET Core version
ENV ASPNET_VERSION=0.0.0

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]
```

--------------------------------

### Final ASP.NET Core Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-8.0-azurelinux3.0-amd64-Dockerfile.approved.txt

Sets the ASP.NET Core version environment variable and copies the installed runtime from the installer stage into the final image.

```dockerfile
# ASP.NET Core image
FROM $REPO:0.0.0-azurelinux3.0-amd64

# ASP.NET Core version
ENV ASPNET_VERSION=0.0.0

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]
```

--------------------------------

### Dockerfile Instructions for SDK Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/sdk-8.0-noble-aot-amd64-Dockerfile.approved.txt

This snippet defines the Dockerfile's build arguments, base image, and copies custom apt sources. It's used to establish the initial environment for the SDK.

```dockerfile
# syntax=docker/dockerfile:1
ARG REPO=mcr.microsoft.com/dotnet/sdk
FROM $REPO:0.0.0-noble-amd64

COPY <<EOF /etc/apt/sources.list.d/arm64.sources
Types: deb
URIs: http://ports.ubuntu.com/ubuntu-ports/
Suites: noble noble-updates
Components: main restricted
Signed-By: /usr/share/keyrings/ubuntu-archive-keyring.gpg
Architectures: arm64
EOF

```

--------------------------------

### Base Image and Chisel Installation

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/runtime-deps-10.0-resolute-chiseled-arm64v8-Dockerfile.approved.txt

Starts from a buildpack-deps image and installs the 'file' utility. It then downloads, verifies, and extracts Chisel, along with a Chisel wrapper script.

```Dockerfile
FROM arm64v8/buildpack-deps:resolute-curl AS chisel

RUN apt-get update && apt-get install -y file

RUN curl --fail --show-error --location --output chisel.tar.gz https://github.com/canonical/chisel/releases/download/v0.0.0/chisel_v0.0.0_linux_arm64.tar.gz 
    && chisel_sha384='{sha386_placeholder}' 
    && echo "$chisel_sha384  chisel.tar.gz" | sha384sum -c - 
    && tar --gzip --extract --no-same-owner --file chisel.tar.gz --directory /usr/bin/ 
    && rm chisel.tar.gz 
    && curl --fail --show-error --location --output /usr/bin/chisel-wrapper https://raw.githubusercontent.com/canonical/rocks-toolbox/v0.0.0/chisel-wrapper 
    && chmod 755 /usr/bin/chisel-wrapper
```

--------------------------------

### Build and Run Sample Image

Source: https://github.com/dotnet/dotnet-docker/blob/main/samples/dotnetapp/README.md

Builds a .NET application image from a Git repository and runs it. Cloning the repo is not necessary.

```console
docker build --pull -t dotnetapp 'https://github.com/dotnet/dotnet-docker.git#:samples/dotnetapp'
docker run --rm dotnetapp
```

--------------------------------

### Final ASP.NET Core Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-10.0-azurelinux3.0-distroless-arm64v8-Dockerfile.approved.txt

Sets the ASP.NET Core version environment variable and copies the installed runtime from the installer stage into the final distroless image.

```Dockerfile
ENV ASPNET_VERSION=0.0.0

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]
```

--------------------------------

### Set up .NET Runtime Image

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/runtime-8.0-bookworm-slim-amd64-Dockerfile.approved.txt

This stage sets the .NET version and copies the installed runtime from the 'installer' stage. It then creates a symbolic link for the 'dotnet' executable in the system's PATH.

```Dockerfile
# .NET runtime image
FROM $REPO:0.0.0-bookworm-slim-amd64

# .NET Runtime version
ENV DOTNET_VERSION=0.0.0

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]

RUN ln -s /usr/share/dotnet/dotnet /usr/bin/dotnet

```

--------------------------------

### Final ASP.NET Core Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-8.0-jammy-arm64v8-Dockerfile.approved.txt

This stage sets the ASP.NET Core version and copies the installed runtime from the 'installer' stage into the final image's /usr/share/dotnet directory.

```Dockerfile
# ASP.NET Core image
FROM $REPO:0.0.0-jammy-arm64v8

# ASP.NET Core version
ENV ASPNET_VERSION=0.0.0

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]

```

--------------------------------

### Dockerfile Base and Installer Stage

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/runtime-11.0-azurelinux3.0-amd64-Dockerfile.approved.txt

Sets up the base repository and downloads the .NET runtime. It installs tar, retrieves the runtime archive and its SHA512 checksum, verifies the checksum, extracts the archive, and cleans up temporary files.

```dockerfile
ARG REPO=mcr.microsoft.com/dotnet/runtime-deps

# Installer image
FROM $REPO:0.0.0-azurelinux3.0-amd64 AS installer

ARG ACCESSTOKEN

RUN tdnf install -y \
        tar \
    && tdnf clean all

# Retrieve .NET Runtime
RUN dotnet_version=0.0.0 \
    && curl --header "Authorization: Bearer $ACCESSTOKEN" --header "x-ms-version: 2017-11-09" --fail --show-error --location \
        --remote-name https://dotnetstage.blob.core.windows.net/Runtime/$dotnet_version/dotnet-runtime-$dotnet_version-linux-x64.tar.gz \
        --remote-name https://dotnetstage.blob.core.windows.net/Runtime/$dotnet_version/dotnet-runtime-$dotnet_version-linux-x64.tar.gz.sha512 \
    && echo "$(cat dotnet-runtime-$dotnet_version-linux-x64.tar.gz.sha512)  dotnet-runtime-$dotnet_version-linux-x64.tar.gz" | sha512sum -c - \
    && mkdir --parents /dotnet \
    && tar --gzip --extract --no-same-owner --file dotnet-runtime-$dotnet_version-linux-x64.tar.gz --directory /dotnet \
    && rm \
        dotnet-runtime-$dotnet_version-linux-x64.tar.gz \
        dotnet-runtime-$dotnet_version-linux-x64.tar.gz.sha512
```

--------------------------------

### Final ASP.NET Core Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-10.0-noble-chiseled-amd64-Dockerfile.approved.txt

This section defines the final ASP.NET Core image, setting the ASP.NET Core version and copying the installed runtime from the installer stage.

```Dockerfile
# ASP.NET Core image
FROM $REPO:0.0.0-noble-chiseled-amd64

# ASP.NET Core version
ENV ASPNET_VERSION=0.0.0

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]

```

--------------------------------

### Final .NET Runtime Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/runtime-10.0-alpine3.23-amd64-Dockerfile.approved.txt

This section defines the final .NET runtime image by copying the installed runtime from the installer stage and creating a symbolic link for the dotnet executable.

```Dockerfile
# .NET runtime image
FROM $REPO:0.0.0-alpine3.XX-amd64

# .NET Runtime version
ENV DOTNET_VERSION=0.0.0

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]

RUN ln -s /usr/share/dotnet/dotnet /usr/bin/dotnet

```

--------------------------------

### Install .NET SDK from a specific URL

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/sdk-8.0-alpine3.22-arm32v7-Dockerfile.approved.txt

This RUN command downloads the .NET SDK tarball and its SHA512 checksum from a specified URL, verifies the checksum, extracts the SDK to a directory, and then cleans up the downloaded files. It uses wget for downloading and sha512sum for verification.

```Dockerfile
RUN dotnet_sdk_version=0.0.0 \
    && dotnet_sdk_build_version=$dotnet_sdk_version \
    && wget --header "Authorization: Bearer $ACCESSTOKEN" --header "x-ms-version: 2017-11-09" \
        https://dotnetstage.blob.core.windows.net/Sdk/$dotnet_sdk_build_version/dotnet-sdk-$dotnet_sdk_build_version-linux-musl-arm.tar.gz \
        https://dotnetstage.blob.core.windows.net/Sdk/$dotnet_sdk_build_version/dotnet-sdk-$dotnet_sdk_build_version-linux-musl-arm.tar.gz.sha512 \
    && echo "$(cat dotnet-sdk-$dotnet_sdk_build_version-linux-musl-arm.tar.gz.sha512)  dotnet-sdk-$dotnet_sdk_build_version-linux-musl-arm.tar.gz" | sha512sum -c - \
    && mkdir --parents /dotnet \
    && tar --gzip --extract --no-same-owner --file dotnet-sdk-$dotnet_sdk_build_version-linux-musl-arm.tar.gz --directory /dotnet ./packs ./sdk ./sdk-manifests ./templates ./LICENSE.txt ./ThirdPartyNotices.txt \
    && rm \
        dotnet-sdk-$dotnet_sdk_build_version-linux-musl-arm.tar.gz \
        dotnet-sdk-$dotnet_sdk_build_version-linux-musl-arm.tar.gz.sha512
```

--------------------------------

### ASP.NET Core Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-8.0-jammy-chiseled-arm64v8-Dockerfile.approved.txt

This stage sets the ASP.NET Core version using an environment variable and copies the installed runtime from the 'installer' stage into the final image's /usr/share/dotnet directory.

```Dockerfile
# ASP.NET Core image
FROM $REPO:0.0.0-jammy-chiseled-arm64v8

# ASP.NET Core version
ENV ASPNET_VERSION=0.0.0

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]
```

--------------------------------

### Install Base Packages and Copy SDK

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/sdk-11.0-azurelinux3.0-amd64-Dockerfile.approved.txt

Installs essential packages like git and tar, then copies the .NET SDK from a previous build stage into the final image. It also creates a symbolic link for 'dnx' and triggers the .NET help command to ensure the SDK is functional.

```Dockerfile
RUN tdnf install -y \
        git \
        libgcc-atomic \
        tar \
    && tdnf clean all

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]

RUN ln -s /usr/share/dotnet/dnx /usr/bin/dnx \
    # Trigger first run experience by running arbitrary cmd
    && dotnet help
```

--------------------------------

### Copy SDK and Trigger First Run

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/sdk-8.0-jammy-arm32v7-Dockerfile.approved.txt

Copies the installed .NET SDK from the 'installer' stage to the final image and runs 'dotnet help' to trigger the first-run experience, ensuring the SDK is functional.

```Dockerfile
COPY --from=installer ["/dotnet", "/usr/share/dotnet"]

# Trigger first run experience by running arbitrary cmd
RUN dotnet help
```

--------------------------------

### Final ASP.NET Core Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-10.0-noble-chiseled-extra-arm32v7-Dockerfile.approved.txt

This section defines the final ASP.NET Core image. It sets the ASP.NET Core version and copies the installed runtime from the 'installer' stage into the final image.

```Dockerfile
# ASP.NET Core image
FROM $REPO:0.0.0-noble-chiseled-extra-arm32v7

# ASP.NET Core version
ENV ASPNET_VERSION=0.0.0

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]
```

--------------------------------

### Install .NET Runtime using Microsoft Package Feed on Debian

Source: https://github.com/dotnet/dotnet-docker/blob/main/documentation/scenarios/installing-dotnet.md

This Dockerfile example demonstrates installing the .NET runtime 8.0 on Debian (bookworm-slim) by first setting up the Microsoft package feed and then installing the package. This approach allows access to packages not available in native distro feeds.

```Dockerfile
FROM debian:bookworm-slim
RUN apt-get update \
    # Install prerequisites
    && apt-get install -y --no-install-recommends \
       wget \
       ca-certificates \
    \
    # Install Microsoft package feed
    && wget -q https://packages.microsoft.com/config/debian/12/packages-microsoft-prod.deb -O packages-microsoft-prod.deb \
    && dpkg -i packages-microsoft-prod.deb \
    && rm packages-microsoft-prod.deb \
    \
    # Install .NET
    && apt-get update \
    && apt-get install -y --no-install-recommends \
        dotnet-runtime-8.0 \
    \
    # Cleanup
    && rm -rf /var/lib/apt/lists/*
```

--------------------------------

### Final ASP.NET Core Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-10.0-noble-chiseled-extra-amd64-Dockerfile.approved.txt

This section defines the final ASP.NET Core image by copying the installed runtime from the 'installer' stage into the base image and setting the ASP.NET Core version environment variable.

```Dockerfile
# ASP.NET Core image
FROM $REPO:0.0.0-noble-chiseled-extra-amd64

# ASP.NET Core version
ENV ASPNET_VERSION=0.0.0

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]

```

--------------------------------

### Set up .NET Runtime Environment

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/runtime-10.0-alpine3.23-arm32v7-Dockerfile.approved.txt

This section copies the extracted .NET runtime from the installer stage into the final image and creates a symbolic link for the 'dotnet' executable.

```Dockerfile
ENV DOTNET_VERSION=0.0.0

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]

RUN ln -s /usr/share/dotnet/dotnet /usr/bin/dotnet
```

--------------------------------

### ASP.NET Core Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-10.0-nanoserver-ltsc2022-amd64-Dockerfile.approved.txt

Sets the ASP.NET Core version using an environment variable and copies the installed runtime from the installer stage to the final image. This stage uses a NanoServer LTSC2022 base image.

```dockerfile
# ASP.NET Core image
FROM $REPO:0.0.0-nanoserver-ltsc2022

# ASP.NET Core version
ENV ASPNET_VERSION=0.0.0

COPY --from=installer ["/dotnet/shared/Microsoft.AspNetCore.App", "/Program Files/dotnet/shared/Microsoft.AspNetCore.App"]

```

--------------------------------

### Set up .NET Runtime Image

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/runtime-10.0-resolute-arm64v8-Dockerfile.approved.txt

This section sets the base image for the .NET runtime, defines the .NET version, copies the extracted runtime from the installer stage, and creates a symbolic link for the dotnet executable. This prepares the final runtime image.

```Dockerfile
# .NET runtime image
FROM $REPO:0.0.0-resolute-arm64v8

# .NET Runtime version
ENV DOTNET_VERSION=0.0.0

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]

RUN ln -s /usr/share/dotnet/dotnet /usr/bin/dotnet

```

--------------------------------

### ASP.NET Core Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-8.0-jammy-chiseled-extra-arm64v8-Dockerfile.approved.txt

This section defines the final ASP.NET Core image using a specified repository and tag. It sets the ASPNET_VERSION environment variable and copies the installed .NET runtime from the installer stage into the final image.

```Dockerfile
# ASP.NET Core image
FROM $REPO:0.0.0-jammy-chiseled-extra-arm64v8

# ASP.NET Core version
ENV ASPNET_VERSION=0.0.0

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]

```

--------------------------------

### Copy Artifacts and Trigger First Run

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/sdk-11.0-windowsservercore-ltsc2022-amd64-Dockerfile.approved.txt

Copies the prepared .NET SDK, PowerShell, and MinGit from the installer stage to their respective locations in the final image. It then runs 'dotnet help' to trigger the first-run experience.

```powershell
COPY --from=installer ["/dotnet", "/Program Files/dotnet"]
COPY --from=installer ["/powershell", "/Program Files/powershell"]
COPY --from=installer ["/MinGit", "/Program Files/MinGit"]
```

```powershell
# Trigger first run experience by running arbitrary cmd
RUN dotnet help
```

--------------------------------

### ASP.NET Composite Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-8.0-noble-chiseled-composite-amd64-Dockerfile.approved.txt

This stage defines the final ASP.NET composite image using a specified repository and tag. It sets environment variables for .NET and ASP.NET versions and copies the installed runtime and the dotnet symlink from the 'installer' stage.

```Dockerfile
# ASP.NET Composite Image
FROM $REPO:0.0.0-noble-chiseled-amd64

ENV \
    # .NET Runtime version
    DOTNET_VERSION=0.0.0 \
    # ASP.NET Core version
    ASPNET_VERSION=0.0.0

COPY --from=installer ["/usr/share/dotnet", "/usr/share/dotnet"]
COPY --from=installer ["/dotnet-symlink", "/usr/bin"]

ENTRYPOINT ["/usr/bin/dotnet"]
CMD ["--info"]
```

--------------------------------

### ASP.NET Composite Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-10.0-resolute-chiseled-composite-extra-arm64v8-Dockerfile.approved.txt

This section defines the base image for the ASP.NET composite image, sets environment variables for .NET and ASP.NET versions, copies the installed runtime and symlink from the installer stage, and sets the entrypoint and default command.

```Dockerfile
FROM $REPO:0.0.0-resolute-chiseled-extra-arm64v8

ENV \
    # .NET Runtime version
    DOTNET_VERSION=0.0.0 \
    # ASP.NET Core version
    ASPNET_VERSION=0.0.0

COPY --from=installer ["/usr/share/dotnet", "/usr/share/dotnet"]
COPY --from=installer ["/dotnet-symlink", "/usr/bin"]

ENTRYPOINT ["/usr/bin/dotnet"]
CMD ["--info"]
```

--------------------------------

### Final ASP.NET Core Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-10.0-noble-arm32v7-Dockerfile.approved.txt

This stage sets the ASP.NET Core version and copies the installed runtime from the installer stage into the final image. It uses a base image specified by the REPO argument and a tag indicating the architecture and base OS.

```Dockerfile
# ASP.NET Core image
FROM $REPO:0.0.0-noble-arm32v7

# ASP.NET Core version
ENV ASPNET_VERSION=0.0.0

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]

```

--------------------------------

### Watch Pod Updates

Source: https://github.com/dotnet/dotnet-docker/blob/main/samples/kubernetes/manual-deployment/README.md

Add the `-w` flag to `kubectl get pod` to continuously watch for updates to your pods, useful when containers are starting.

```bash
kubectl get pod -w
```

--------------------------------

### Install Dependencies and .NET SDK

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/sdk-10.0-azurelinux3.0-amd64-Dockerfile.approved.txt

Installs necessary packages like tar and then downloads, verifies, and extracts the .NET SDK from a specified URL using an access token. It cleans up downloaded archives afterward.

```Dockerfile
ARG REPO=mcr.microsoft.com/dotnet/aspnet
# Installer image
FROM $REPO:0.0.0-azurelinux3.0-amd64 AS installer

ARG ACCESSTOKEN

RUN tdnf install -y \
        tar \
    && tdnf clean all

# Install .NET SDK
RUN dotnet_sdk_version=0.0.0 \
    && dotnet_sdk_build_version=$dotnet_sdk_version \
    && curl --header "Authorization: Bearer $ACCESSTOKEN" --header "x-ms-version: 2017-11-09" --fail --show-error --location \
        --remote-name https://dotnetstage.blob.core.windows.net/Sdk/$dotnet_sdk_build_version/dotnet-sdk-$dotnet_sdk_build_version-linux-x64.tar.gz \
        --remote-name https://dotnetstage.blob.core.windows.net/Sdk/$dotnet_sdk_build_version/dotnet-sdk-$dotnet_sdk_build_version-linux-x64.tar.gz.sha512 \
    && echo "$(cat dotnet-sdk-$dotnet_sdk_build_version-linux-x64.tar.gz.sha512)  dotnet-sdk-$dotnet_sdk_build_version-linux-x64.tar.gz" | sha512sum -c - \
    && mkdir --parents /dotnet \
    && tar --gzip --extract --no-same-owner --file dotnet-sdk-$dotnet_sdk_build_version-linux-x64.tar.gz --directory /dotnet ./dnx ./packs ./sdk ./sdk-manifests ./templates ./LICENSE.txt ./ThirdPartyNotices.txt \
    && rm \
        dotnet-sdk-$dotnet_sdk_build_version-linux-x64.tar.gz \
        dotnet-sdk-$dotnet_sdk_build_version-linux-x64.tar.gz.sha512
```

--------------------------------

### ASP.NET Composite Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-9.0-noble-chiseled-composite-extra-amd64-Dockerfile.approved.txt

This snippet defines the final ASP.NET composite image using a specified repository and tag. It sets environment variables for .NET and ASP.NET Core versions and copies the installed runtime and dotnet symlink from the 'installer' stage into the final image.

```Dockerfile
# ASP.NET Composite Image
FROM $REPO:0.0.0-noble-chiseled-extra-amd64

ENV 
    # .NET Runtime version
    DOTNET_VERSION=0.0.0 
    # ASP.NET Core version
    ASPNET_VERSION=0.0.0

COPY --from=installer ["/usr/share/dotnet", "/usr/share/dotnet"]
COPY --from=installer ["/dotnet-symlink", "/usr/bin"]

ENTRYPOINT ["/usr/bin/dotnet"]
CMD ["--info"]
```

--------------------------------

### Install Dependencies and Download ASP.NET Runtime

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-8.0-cbl-mariner2.0-distroless-composite-amd64-Dockerfile.approved.txt

Installs necessary packages like ca-certificates, gzip, and tar. It then downloads the ASP.NET composite runtime and its SHA512 checksum using a provided access token, verifies the checksum, extracts the runtime to /usr/share/dotnet, and cleans up downloaded files.

```Dockerfile
RUN tdnf install -y \
        ca-certificates \
        gzip \
        tar \
    && tdnf clean all

# Retrieve ASP.NET Composite Runtime
RUN aspnetcore_version=0.0.0 \
    && aspnetcore_build_version=$aspnetcore_version \
    && curl --header "Authorization: Bearer $ACCESSTOKEN" --header "x-ms-version: 2017-11-09" --fail --show-error --location \
        --remote-name https://dotnetstage.blob.core.windows.net/aspnetcore/Runtime/$aspnetcore_build_version/aspnetcore-runtime-composite-$aspnetcore_build_version-linux-x64.tar.gz \
        --remote-name https://dotnetstage.blob.core.windows.net/aspnetcore/Runtime/$aspnetcore_build_version/aspnetcore-runtime-composite-$aspnetcore_build_version-linux-x64.tar.gz.sha512 \
    && echo "$(cat aspnetcore-runtime-composite-$aspnetcore_build_version-linux-x64.tar.gz.sha512)  aspnetcore-runtime-composite-$aspnetcore_build_version-linux-x64.tar.gz" | sha512sum -c - \
    && mkdir --parents /usr/share/dotnet \
    && tar --gzip --extract --no-same-owner --file aspnetcore-runtime-composite-$aspnetcore_build_version-linux-x64.tar.gz --directory /usr/share/dotnet \
    && rm \
        aspnetcore-runtime-composite-$aspnetcore_build_version-linux-x64.tar.gz \
        aspnetcore-runtime-composite-$aspnetcore_build_version-linux-x64.tar.gz.sha512

RUN mkdir /dotnet-symlink \
    && ln -s /usr/share/dotnet/dotnet /dotnet-symlink/dotnet
```

--------------------------------

### Install .NET SDK

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/sdk-10.0-noble-arm32v7-Dockerfile.approved.txt

Downloads and installs the .NET SDK from a specified URL, verifying its integrity using a SHA512 checksum. It then extracts the SDK components to a designated directory.

```Dockerfile
ARG REPO=mcr.microsoft.com/dotnet/aspnet
# Installer image
FROM arm32v7/buildpack-deps:jammy-curl AS installer

ARG ACCESSTOKEN

# Install .NET SDK
RUN dotnet_sdk_version=0.0.0 \
    && dotnet_sdk_build_version=$dotnet_sdk_version \
    && curl --header "Authorization: Bearer $ACCESSTOKEN" --header "x-ms-version: 2017-11-09" --fail --show-error --location \
        --remote-name https://dotnetstage.blob.core.windows.net/Sdk/$dotnet_sdk_build_version/dotnet-sdk-$dotnet_sdk_build_version-linux-arm.tar.gz \
        --remote-name https://dotnetstage.blob.core.windows.net/Sdk/$dotnet_sdk_build_version/dotnet-sdk-$dotnet_sdk_build_version-linux-arm.tar.gz.sha512 \
    && echo "$(cat dotnet-sdk-$dotnet_sdk_build_version-linux-arm.tar.gz.sha512)  dotnet-sdk-$dotnet_sdk_build_version-linux-arm.tar.gz" | sha512sum -c - \
    && mkdir --parents /dotnet \
    && tar --gzip --extract --no-same-owner --file dotnet-sdk-$dotnet_sdk_build_version-linux-arm.tar.gz --directory /dotnet ./dnx ./packs ./sdk ./sdk-manifests ./templates ./LICENSE.txt ./ThirdPartyNotices.txt \
    && rm \
        dotnet-sdk-$dotnet_sdk_build_version-linux-arm.tar.gz \
        dotnet-sdk-$dotnet_sdk_build_version-linux-arm.tar.gz.sha512
```

--------------------------------

### ASP.NET Composite Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/aspnet-10.0-noble-chiseled-composite-extra-arm64v8-Dockerfile.approved.txt

This section defines the final ASP.NET Composite Image. It sets environment variables for .NET and ASP.NET Core versions and copies the installed runtime and dotnet symlink from the 'installer' stage. The ENTRYPOINT is set to the dotnet executable, and the default CMD is '--info'.

```Dockerfile
# ASP.NET Composite Image
FROM $REPO:0.0.0-noble-chiseled-extra-arm64v8

ENV \
    # .NET Runtime version
    DOTNET_VERSION=0.0.0 \
    # ASP.NET Core version
    ASPNET_VERSION=0.0.0

COPY --from=installer ["/usr/share/dotnet", "/usr/share/dotnet"]
COPY --from=installer ["/dotnet-symlink", "/usr/bin"]

ENTRYPOINT ["/usr/bin/dotnet"]
CMD ["--info"]
```

--------------------------------

### Install .NET SDK

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/sdk-9.0-noble-arm32v7-Dockerfile.approved.txt

Downloads and installs the .NET SDK from a specified URL, verifying its integrity using a SHA512 checksum. This stage is used to prepare the SDK for copying into the final image.

```Dockerfile
ARG REPO=mcr.microsoft.com/dotnet/aspnet
# Installer image
FROM arm32v7/buildpack-deps:jammy-curl AS installer

ARG ACCESSTOKEN

# Install .NET SDK
RUN dotnet_sdk_version=0.0.0 \
    && dotnet_sdk_build_version=$dotnet_sdk_version \
    && curl --header "Authorization: Bearer $ACCESSTOKEN" --header "x-ms-version: 2017-11-09" --fail --show-error --location \
        --remote-name https://dotnetstage.blob.core.windows.net/Sdk/$dotnet_sdk_build_version/dotnet-sdk-$dotnet_sdk_build_version-linux-arm.tar.gz \
        --remote-name https://dotnetstage.blob.core.windows.net/Sdk/$dotnet_sdk_version/dotnet-sdk-$dotnet_sdk_version-linux-arm.tar.gz.sha512 \
    && echo "$(cat dotnet-sdk-$dotnet_sdk_build_version-linux-arm.tar.gz.sha512)  dotnet-sdk-$dotnet_sdk_build_version-linux-arm.tar.gz" | sha512sum -c - \
    && mkdir --parents /dotnet \
    && tar --gzip --extract --no-same-owner --file dotnet-sdk-$dotnet_sdk_build_version-linux-arm.tar.gz --directory /dotnet ./packs ./sdk ./sdk-manifests ./templates ./LICENSE.txt ./ThirdPartyNotices.txt \
    && rm \
        dotnet-sdk-$dotnet_sdk_build_version-linux-arm.tar.gz \
        dotnet-sdk-$dotnet_sdk_build_version-linux-arm.tar.gz.sha512
```

--------------------------------

### .NET Runtime Image Setup

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/runtime-10.0-alpine3.22-extra-arm32v7-Dockerfile.approved.txt

Sets the DOTNET_VERSION environment variable and copies the extracted .NET runtime from the installer stage. It then creates a symbolic link for the dotnet executable.

```dockerfile
# .NET runtime image
FROM $REPO:0.0.0-alpine3.XX-extra-arm32v7

# .NET Runtime version
ENV DOTNET_VERSION=0.0.0

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]

RUN ln -s /usr/share/dotnet/dotnet /usr/bin/dotnet
```

--------------------------------

### Install .NET SDK from Archive

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/sdk-11.0-alpine3.23-amd64-Dockerfile.approved.txt

Downloads, verifies, and extracts the .NET SDK from a tarball. Requires an access token for authenticated download.

```Dockerfile
ARG REPO=mcr.microsoft.com/dotnet/aspnet
# Installer image
FROM $REPO:0.0.0-alpine3.XX-amd64 AS installer

ARG ACCESSTOKEN

# Install .NET SDK
RUN dotnet_sdk_version=0.0.0 \
    && wget --header "Authorization: Bearer $ACCESSTOKEN" --header "x-ms-version: 2017-11-09" \
        https://dotnetstage.blob.core.windows.net/Sdk/$dotnet_sdk_version/dotnet-sdk-$dotnet_sdk_version-linux-musl-x64.tar.gz \
        https://dotnetstage.blob.core.windows.net/Sdk/$dotnet_sdk_version/dotnet-sdk-$dotnet_sdk_version-linux-musl-x64.tar.gz.sha512 \
    && echo "$(cat dotnet-sdk-$dotnet_sdk_version-linux-musl-x64.tar.gz.sha512)  dotnet-sdk-$dotnet_sdk_version-linux-musl-x64.tar.gz" | sha512sum -c - \
    && mkdir --parents /dotnet \
    && tar --gzip --extract --no-same-owner --file dotnet-sdk-$dotnet_sdk_version-linux-musl-x64.tar.gz --directory /dotnet ./dnx ./packs ./sdk ./sdk-manifests ./templates ./LICENSE.txt ./ThirdPartyNotices.txt \
    && rm \
        dotnet-sdk-$dotnet_sdk_version-linux-musl-x64.tar.gz \
        dotnet-sdk-$dotnet_sdk_version-linux-musl-x64.tar.gz.sha512
```

--------------------------------

### Install Dependencies and Copy SDK

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/sdk-9.0-alpine3.23-arm64v8-Dockerfile.approved.txt

Installs essential packages like curl, git, and ICU libraries using apk. It then copies the extracted .NET SDK from the installer stage into the final image and runs 'dotnet help' to trigger the first-run experience.

```Dockerfile
RUN apk add --upgrade --no-cache \
        curl \
        git \
        icu-data-full \
        icu-libs \
        libatomic \
        tzdata

COPY --from=installer ["/dotnet", "/usr/share/dotnet"]

# Trigger first run experience by running arbitrary cmd
RUN dotnet help
```

--------------------------------

### Example .NET Docker Image Variants

Source: https://github.com/dotnet/dotnet-docker/blob/main/documentation/supported-tags.md

Append variant names like 'extra' or 'chiseled' to the OS name for specific image features. These are available starting with .NET 8.0.

```dockerfile
8.0-noble-chiseled
```

```dockerfile
8.0.11-noble-chiseled-extra
```

```dockerfile
9.0.0-alpine3.21-extra
```

--------------------------------

### Install Dependencies and Download .NET Monitor

Source: https://github.com/dotnet/dotnet-docker/blob/main/tests/Microsoft.DotNet.Docker.Tests/Baselines/GeneratedArtifactTests/VerifyInternalDockerfilesOutput/monitor-base-10.0-azurelinux-distroless-arm64v8-Dockerfile.approved.txt

This stage installs necessary packages like ca-certificates, gzip, and tar. It then downloads the .NET Monitor base archive and its SHA512 checksum, verifies the integrity using sha512sum, extracts the archive, and cleans up the downloaded files.

```Dockerfile
ARG REPO=mcr.microsoft.com/dotnet/aspnet

# Installer image
FROM mcr.microsoft.com/azurelinux/base/core:3.0 AS installer

ARG ACCESSTOKEN

RUN tdnf install -y \
        ca-certificates \
        gzip \
        tar \
    && tdnf clean all

# Retrieve .NET Monitor Base
RUN dotnet_monitor_version=0.0.0 \
    && curl --header "Authorization: Bearer $ACCESSTOKEN" --header "x-ms-version: 2017-11-09" --fail --show-error --location \
        --remote-name https://dotnetstage.blob.core.windows.net/$dotnet_monitor_version/BlobAssets/dotnet-monitor-base-$dotnet_monitor_version-linux-arm64.tar.gz \
        --remote-name https://dotnetstage.blob.core.windows.net/$dotnet_monitor_version/ChecksumAssets/dotnet-monitor-base-$dotnet_monitor_version-linux-arm64.tar.gz.sha512 \
    && echo "$(cat dotnet-monitor-base-$dotnet_monitor_version-linux-arm64.tar.gz.sha512)  dotnet-monitor-base-$dotnet_monitor_version-linux-arm64.tar.gz" | sha512sum -c - \
    && mkdir --parents /app \
    && tar --gzip --extract --no-same-owner --file dotnet-monitor-base-$dotnet_monitor_version-linux-arm64.tar.gz --directory /app \
    && rm  \
        dotnet-monitor-base-$dotnet_monitor_version-linux-arm64.tar.gz \
        dotnet-monitor-base-$dotnet_monitor_version-linux-arm64.tar.gz.sha512
```