Debian/Armbian 的官方 apt 源已经不再提供 .NET 6 ARM32 包,因为 Microsoft 官方仅对新版 Debian/Ubuntu 的 apt 源发布 x64 和 ARM64 包,不发布 ARM32 (linux‑arm) 的安装包,所以无法直接用 apt install aspnetcore-runtime‑6.0 这类命令安装。

不过还有 两种方法 可以在你的 ARMv7 玩客云 / Armbian 上运行 .NET:

方法 1 — 使用微软提供的 dotnet-install.sh 脚本(推荐)

微软官方提供了一个脚本,可以下载安装 .NET 任意版本(包括 ARM32)。下载完成后你可以运行 ASP.NET Core 应用,但不会注册到 apt 包管理。

安装步骤

  1. 下载脚本:

    wget https://dot.net/v1/dotnet-install.sh -O dotnet-install.sh
    chmod +x dotnet-install.sh
    

    如果无法下载,下面是完整的内容,可新建一个本地脚本

    #!/usr/bin/env bash
    # Copyright (c) .NET Foundation and contributors. All rights reserved.
    # Licensed under the MIT license. See LICENSE file in the project root for full license information.
    #
    
    # Stop script on NZEC
    set -e
    # Stop script if unbound variable found (use ${var:-} if intentional)
    set -u
    # By default cmd1 | cmd2 returns exit code of cmd2 regardless of cmd1 success
    # This is causing it to fail
    set -o pipefail
    
    # Use in the the functions: eval $invocation
    invocation='say_verbose "Calling: ${yellow:-}${FUNCNAME[0]} ${green:-}$*${normal:-}"'
    
    # standard output may be used as a return value in the functions
    # we need a way to write text on the screen in the functions so that
    # it won't interfere with the return value.
    # Exposing stream 3 as a pipe to standard output of the script itself
    exec 3>&1
    
    # Setup some colors to use. These need to work in fairly limited shells, like the Ubuntu Docker container where there are only 8 colors.
    # See if stdout is a terminal
    if [ -t 1 ] && command -v tput > /dev/null; then
        # see if it supports colors
        ncolors=$(tput colors || echo 0)
        if [ -n "$ncolors" ] && [ $ncolors -ge 8 ]; then
            bold="$(tput bold       || echo)"
            normal="$(tput sgr0     || echo)"
            black="$(tput setaf 0   || echo)"
            red="$(tput setaf 1     || echo)"
            green="$(tput setaf 2   || echo)"
            yellow="$(tput setaf 3  || echo)"
            blue="$(tput setaf 4    || echo)"
            magenta="$(tput setaf 5 || echo)"
            cyan="$(tput setaf 6    || echo)"
            white="$(tput setaf 7   || echo)"
        fi
    fi
    
    say_warning() {
        printf "%b\n" "${yellow:-}dotnet_install: Warning: $1${normal:-}" >&3
    }
    
    say_err() {
        printf "%b\n" "${red:-}dotnet_install: Error: $1${normal:-}" >&2
    }
    
    say() {
        # using stream 3 (defined in the beginning) to not interfere with stdout of functions
        # which may be used as return value
        printf "%b\n" "${cyan:-}dotnet-install:${normal:-} $1" >&3
    }
    
    say_verbose() {
        if [ "$verbose" = true ]; then
            say "$1"
        fi
    }
    
    # This platform list is finite - if the SDK/Runtime has supported Linux distribution-specific assets,
    #   then and only then should the Linux distribution appear in this list.
    # Adding a Linux distribution to this list does not imply distribution-specific support.
    get_legacy_os_name_from_platform() {
        eval $invocation
    
        platform="$1"
        case "$platform" in
            "centos.7")
                echo "centos"
                return 0
                ;;
            "debian.8")
                echo "debian"
                return 0
                ;;
            "debian.9")
                echo "debian.9"
                return 0
                ;;
            "fedora.23")
                echo "fedora.23"
                return 0
                ;;
            "fedora.24")
                echo "fedora.24"
                return 0
                ;;
            "fedora.27")
                echo "fedora.27"
                return 0
                ;;
            "fedora.28")
                echo "fedora.28"
                return 0
                ;;
            "opensuse.13.2")
                echo "opensuse.13.2"
                return 0
                ;;
            "opensuse.42.1")
                echo "opensuse.42.1"
                return 0
                ;;
            "opensuse.42.3")
                echo "opensuse.42.3"
                return 0
                ;;
            "rhel.7"*)
                echo "rhel"
                return 0
                ;;
            "ubuntu.14.04")
                echo "ubuntu"
                return 0
                ;;
            "ubuntu.16.04")
                echo "ubuntu.16.04"
                return 0
                ;;
            "ubuntu.16.10")
                echo "ubuntu.16.10"
                return 0
                ;;
            "ubuntu.18.04")
                echo "ubuntu.18.04"
                return 0
                ;;
            "alpine.3.4.3")
                echo "alpine"
                return 0
                ;;
        esac
        return 1
    }
    
    get_legacy_os_name() {
        eval $invocation
    
        local uname=$(uname)
        if [ "$uname" = "Darwin" ]; then
            echo "osx"
            return 0
        elif [ -n "$runtime_id" ]; then
            echo $(get_legacy_os_name_from_platform "${runtime_id%-*}" || echo "${runtime_id%-*}")
            return 0
        else
            if [ -e /etc/os-release ]; then
                . /etc/os-release
                os=$(get_legacy_os_name_from_platform "$ID${VERSION_ID:+.${VERSION_ID}}" || echo "")
                if [ -n "$os" ]; then
                    echo "$os"
                    return 0
                fi
            fi
        fi
    
        say_verbose "Distribution specific OS name and version could not be detected: UName = $uname"
        return 1
    }
    
    get_linux_platform_name() {
        eval $invocation
    
        if [ -n "$runtime_id" ]; then
            echo "${runtime_id%-*}"
            return 0
        else
            if [ -e /etc/os-release ]; then
                . /etc/os-release
                echo "$ID${VERSION_ID:+.${VERSION_ID}}"
                return 0
            elif [ -e /etc/redhat-release ]; then
                local redhatRelease=$(</etc/redhat-release)
                if [[ $redhatRelease == "CentOS release 6."* || $redhatRelease == "Red Hat Enterprise Linux "*" release 6."* ]]; then
                    echo "rhel.6"
                    return 0
                fi
            fi
        fi
    
        say_verbose "Linux specific platform name and version could not be detected: UName = $uname"
        return 1
    }
    
    is_musl_based_distro() {
        (ldd --version 2>&1 || true) | grep -q musl
    }
    
    get_current_os_name() {
        eval $invocation
    
        local uname=$(uname)
        if [ "$uname" = "Darwin" ]; then
            echo "osx"
            return 0
        elif [ "$uname" = "FreeBSD" ]; then
            echo "freebsd"
            return 0
        elif [ "$uname" = "Linux" ]; then
            local linux_platform_name=""
            linux_platform_name="$(get_linux_platform_name)" || true
    
            if [ "$linux_platform_name" = "rhel.6" ]; then
                echo $linux_platform_name
                return 0
            elif is_musl_based_distro; then
                echo "linux-musl"
                return 0
            elif [ "$linux_platform_name" = "linux-musl" ]; then
                echo "linux-musl"
                return 0
            else
                echo "linux"
                return 0
            fi
        fi
    
        say_err "OS name could not be detected: UName = $uname"
        return 1
    }
    
    machine_has() {
        eval $invocation
    
        command -v "$1" > /dev/null 2>&1
        return $?
    }
    
    check_min_reqs() {
        local hasMinimum=false
        if machine_has "curl"; then
            hasMinimum=true
        elif machine_has "wget"; then
            hasMinimum=true
        fi
    
        if [ "$hasMinimum" = "false" ]; then
            say_err "curl (recommended) or wget are required to download dotnet. Install missing prerequisite to proceed."
            return 1
        fi
        return 0
    }
    
    # args:
    # input - $1
    to_lowercase() {
        #eval $invocation
    
        echo "$1" | tr '[:upper:]' '[:lower:]'
        return 0
    }
    
    # args:
    # input - $1
    remove_trailing_slash() {
        #eval $invocation
    
        local input="${1:-}"
        echo "${input%/}"
        return 0
    }
    
    # args:
    # input - $1
    remove_beginning_slash() {
        #eval $invocation
    
        local input="${1:-}"
        echo "${input#/}"
        return 0
    }
    
    # args:
    # root_path - $1
    # child_path - $2 - this parameter can be empty
    combine_paths() {
        eval $invocation
    
        # TODO: Consider making it work with any number of paths. For now:
        if [ ! -z "${3:-}" ]; then
            say_err "combine_paths: Function takes two parameters."
            return 1
        fi
    
        local root_path="$(remove_trailing_slash "$1")"
        local child_path="$(remove_beginning_slash "${2:-}")"
        say_verbose "combine_paths: root_path=$root_path"
        say_verbose "combine_paths: child_path=$child_path"
        echo "$root_path/$child_path"
        return 0
    }
    
    get_machine_architecture() {
        eval $invocation
    
        if command -v uname > /dev/null; then
            CPUName=$(uname -m)
            case $CPUName in
            armv1*|armv2*|armv3*|armv4*|armv5*|armv6*)
                echo "armv6-or-below"
                return 0
                ;;
            armv*l)
                echo "arm"
                return 0
                ;;
            aarch64|arm64)
                if [ "$(getconf LONG_BIT)" -lt 64 ]; then
                    # This is 32-bit OS running on 64-bit CPU (for example Raspberry Pi OS)
                    echo "arm"
                    return 0
                fi
                echo "arm64"
                return 0
                ;;
            s390x)
                echo "s390x"
                return 0
                ;;
            ppc64le)
                echo "ppc64le"
                return 0
                ;;
            loongarch64)
                echo "loongarch64"
                return 0
                ;;
            riscv64)
                echo "riscv64"
                return 0
                ;;
            powerpc|ppc)
                echo "ppc"
                return 0
                ;;
            esac
        fi
    
        # Always default to 'x64'
        echo "x64"
        return 0
    }
    
    # args:
    # architecture - $1
    get_normalized_architecture_from_architecture() {
        eval $invocation
    
        local architecture="$(to_lowercase "$1")"
    
        if [[ $architecture == \<auto\> ]]; then
            machine_architecture="$(get_machine_architecture)"
            if [[ "$machine_architecture" == "armv6-or-below" ]]; then
                say_err "Architecture \`$machine_architecture\` not supported. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues"
                return 1
            fi
    
            echo $machine_architecture
            return 0
        fi
    
        case "$architecture" in
            amd64|x64)
                echo "x64"
                return 0
                ;;
            arm)
                echo "arm"
                return 0
                ;;
            arm64)
                echo "arm64"
                return 0
                ;;
            s390x)
                echo "s390x"
                return 0
                ;;
            ppc64le)
                echo "ppc64le"
                return 0
                ;;
            loongarch64)
                echo "loongarch64"
                return 0
                ;;
        esac
    
        say_err "Architecture \`$architecture\` not supported. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues"
        return 1
    }
    
    # args:
    # version - $1
    # channel - $2
    # architecture - $3
    get_normalized_architecture_for_specific_sdk_version() {
        eval $invocation
    
        local is_version_support_arm64="$(is_arm64_supported "$1")"
        local is_channel_support_arm64="$(is_arm64_supported "$2")"
        local architecture="$3";
        local osname="$(get_current_os_name)"
    
        if [ "$osname" == "osx" ] && [ "$architecture" == "arm64" ] && { [ "$is_version_support_arm64" = false ] || [ "$is_channel_support_arm64" = false ]; }; then
            #check if rosetta is installed
            if [ "$(/usr/bin/pgrep oahd >/dev/null 2>&1;echo $?)" -eq 0 ]; then 
                say_verbose "Changing user architecture from '$architecture' to 'x64' because .NET SDKs prior to version 6.0 do not support arm64." 
                echo "x64"
                return 0;
            else
                say_err "Architecture \`$architecture\` is not supported for .NET SDK version \`$version\`. Please install Rosetta to allow emulation of the \`$architecture\` .NET SDK on this platform"
                return 1
            fi
        fi
    
        echo "$architecture"
        return 0
    }
    
    # args:
    # version or channel - $1
    is_arm64_supported() {
        # Extract the major version by splitting on the dot
        major_version="${1%%.*}"
    
        # Check if the major version is a valid number and less than 6
        case "$major_version" in
            [0-9]*)  
                if [ "$major_version" -lt 6 ]; then
                    echo false
                    return 0
                fi
                ;;
        esac
    
        echo true
        return 0
    }
    
    # args:
    # user_defined_os - $1
    get_normalized_os() {
        eval $invocation
    
        local osname="$(to_lowercase "$1")"
        if [ ! -z "$osname" ]; then
            case "$osname" in
                osx | freebsd | rhel.6 | linux-musl | linux)
                    echo "$osname"
                    return 0
                    ;;
                macos)
                    osname='osx'
                    echo "$osname"
                    return 0
                    ;;
                *)
                    say_err "'$user_defined_os' is not a supported value for --os option, supported values are: osx, macos, linux, linux-musl, freebsd, rhel.6. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues."
                    return 1
                    ;;
            esac
        else
            osname="$(get_current_os_name)" || return 1
        fi
        echo "$osname"
        return 0
    }
    
    # args:
    # quality - $1
    get_normalized_quality() {
        eval $invocation
    
        local quality="$(to_lowercase "$1")"
        if [ ! -z "$quality" ]; then
            case "$quality" in
                daily | preview)
                    echo "$quality"
                    return 0
                    ;;
                ga)
                    #ga quality is available without specifying quality, so normalizing it to empty
                    return 0
                    ;;
                *)
                    say_err "'$quality' is not a supported value for --quality option. Supported values are: daily, preview, ga. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues."
                    return 1
                    ;;
            esac
        fi
        return 0
    }
    
    # args:
    # channel - $1
    get_normalized_channel() {
        eval $invocation
    
        local channel="$(to_lowercase "$1")"
    
        if [[ $channel == current ]]; then
            say_warning 'Value "Current" is deprecated for -Channel option. Use "STS" instead.'
        fi
    
        if [[ $channel == release/* ]]; then
            say_warning 'Using branch name with -Channel option is no longer supported with newer releases. Use -Quality option with a channel in X.Y format instead.';
        fi
    
        if [ ! -z "$channel" ]; then
            case "$channel" in
                lts)
                    echo "LTS"
                    return 0
                    ;;
                sts)
                    echo "STS"
                    return 0
                    ;;
                current)
                    echo "STS"
                    return 0
                    ;;
                *)
                    echo "$channel"
                    return 0
                    ;;
            esac
        fi
    
        return 0
    }
    
    # args:
    # runtime - $1
    get_normalized_product() {
        eval $invocation
    
        local product=""
        local runtime="$(to_lowercase "$1")"
        if [[ "$runtime" == "dotnet" ]]; then
            product="dotnet-runtime"
        elif [[ "$runtime" == "aspnetcore" ]]; then
            product="aspnetcore-runtime"
        elif [ -z "$runtime" ]; then
            product="dotnet-sdk"
        fi
        echo "$product"
        return 0
    }
    
    # The version text returned from the feeds is a 1-line or 2-line string:
    # For the SDK and the dotnet runtime (2 lines):
    # Line 1: # commit_hash
    # Line 2: # 4-part version
    # For the aspnetcore runtime (1 line):
    # Line 1: # 4-part version
    
    # args:
    # version_text - stdin
    get_version_from_latestversion_file_content() {
        eval $invocation
    
        cat | tail -n 1 | sed 's/\r$//'
        return 0
    }
    
    # args:
    # install_root - $1
    # relative_path_to_package - $2
    # specific_version - $3
    is_dotnet_package_installed() {
        eval $invocation
    
        local install_root="$1"
        local relative_path_to_package="$2"
        local specific_version="${3//[$'\t\r\n']}"
    
        local dotnet_package_path="$(combine_paths "$(combine_paths "$install_root" "$relative_path_to_package")" "$specific_version")"
        say_verbose "is_dotnet_package_installed: dotnet_package_path=$dotnet_package_path"
    
        if [ -d "$dotnet_package_path" ]; then
            return 0
        else
            return 1
        fi
    }
    
    # args:
    # downloaded file - $1
    # remote_file_size - $2
    validate_remote_local_file_sizes() 
    {
        eval $invocation
    
        local downloaded_file="$1"
        local remote_file_size="$2"
        local file_size=''
    
        if [[ "$OSTYPE" == "linux-gnu"* ]]; then
            file_size="$(stat -c '%s' "$downloaded_file")"
        elif [[ "$OSTYPE" == "darwin"* ]]; then
            # hardcode in order to avoid conflicts with GNU stat
            file_size="$(/usr/bin/stat -f '%z' "$downloaded_file")"
        fi  
        
        if [ -n "$file_size" ]; then
            say "Downloaded file size is $file_size bytes."
    
            if [ -n "$remote_file_size" ] && [ -n "$file_size" ]; then
                if [ "$remote_file_size" -ne "$file_size" ]; then
                    say "The remote and local file sizes are not equal. The remote file size is $remote_file_size bytes and the local size is $file_size bytes. The local package may be corrupted."
                else
                    say "The remote and local file sizes are equal."
                fi
            fi
            
        else
            say "Either downloaded or local package size can not be measured. One of them may be corrupted."      
        fi 
    }
    
    # args:
    # azure_feed - $1
    # channel - $2
    # normalized_architecture - $3
    get_version_from_latestversion_file() {
        eval $invocation
    
        local azure_feed="$1"
        local channel="$2"
        local normalized_architecture="$3"
    
        local version_file_url=null
        if [[ "$runtime" == "dotnet" ]]; then
            version_file_url="$azure_feed/Runtime/$channel/latest.version"
        elif [[ "$runtime" == "aspnetcore" ]]; then
            version_file_url="$azure_feed/aspnetcore/Runtime/$channel/latest.version"
        elif [ -z "$runtime" ]; then
             version_file_url="$azure_feed/Sdk/$channel/latest.version"
        else
            say_err "Invalid value for \$runtime"
            return 1
        fi
        say_verbose "get_version_from_latestversion_file: latest url: $version_file_url"
    
        download "$version_file_url" || return $?
        return 0
    }
    
    # args:
    # json_file - $1
    parse_globaljson_file_for_version() {
        eval $invocation
    
        local json_file="$1"
        if [ ! -f "$json_file" ]; then
            say_err "Unable to find \`$json_file\`"
            return 1
        fi
    
        sdk_section=$(cat "$json_file" | tr -d "\r" | awk '/"sdk"/,/}/')
        if [ -z "$sdk_section" ]; then
            say_err "Unable to parse the SDK node in \`$json_file\`"
            return 1
        fi
    
        sdk_list=$(echo $sdk_section | awk -F"[{}]" '{print $2}')
        sdk_list=${sdk_list//[\" ]/}
        sdk_list=${sdk_list//,/$'\n'}
    
        local version_info=""
        while read -r line; do
          IFS=:
          while read -r key value; do
            if [[ "$key" == "version" ]]; then
              version_info=$value
            fi
          done <<< "$line"
        done <<< "$sdk_list"
        if [ -z "$version_info" ]; then
            say_err "Unable to find the SDK:version node in \`$json_file\`"
            return 1
        fi
    
        unset IFS;
        echo "$version_info"
        return 0
    }
    
    # args:
    # azure_feed - $1
    # channel - $2
    # normalized_architecture - $3
    # version - $4
    # json_file - $5
    get_specific_version_from_version() {
        eval $invocation
    
        local azure_feed="$1"
        local channel="$2"
        local normalized_architecture="$3"
        local version="$(to_lowercase "$4")"
        local json_file="$5"
    
        if [ -z "$json_file" ]; then
            if [[ "$version" == "latest" ]]; then
                local version_info
                version_info="$(get_version_from_latestversion_file "$azure_feed" "$channel" "$normalized_architecture" false)" || return 1
                say_verbose "get_specific_version_from_version: version_info=$version_info"
                echo "$version_info" | get_version_from_latestversion_file_content
                return 0
            else
                echo "$version"
                return 0
            fi
        else
            local version_info
            version_info="$(parse_globaljson_file_for_version "$json_file")" || return 1
            echo "$version_info"
            return 0
        fi
    }
    
    # args:
    # azure_feed - $1
    # channel - $2
    # normalized_architecture - $3
    # specific_version - $4
    # normalized_os - $5
    construct_download_link() {
        eval $invocation
    
        local azure_feed="$1"
        local channel="$2"
        local normalized_architecture="$3"
        local specific_version="${4//[$'\t\r\n']}"
        local specific_product_version="$(get_specific_product_version "$1" "$4")"
        local osname="$5"
    
        local download_link=null
        if [[ "$runtime" == "dotnet" ]]; then
            download_link="$azure_feed/Runtime/$specific_version/dotnet-runtime-$specific_product_version-$osname-$normalized_architecture.tar.gz"
        elif [[ "$runtime" == "aspnetcore" ]]; then
            download_link="$azure_feed/aspnetcore/Runtime/$specific_version/aspnetcore-runtime-$specific_product_version-$osname-$normalized_architecture.tar.gz"
        elif [ -z "$runtime" ]; then
            download_link="$azure_feed/Sdk/$specific_version/dotnet-sdk-$specific_product_version-$osname-$normalized_architecture.tar.gz"
        else
            return 1
        fi
    
        echo "$download_link"
        return 0
    }
    
    # args:
    # azure_feed - $1
    # specific_version - $2
    # download link - $3 (optional)
    get_specific_product_version() {
        # If we find a 'productVersion.txt' at the root of any folder, we'll use its contents
        # to resolve the version of what's in the folder, superseding the specified version.
        # if 'productVersion.txt' is missing but download link is already available, product version will be taken from download link
        eval $invocation
    
        local azure_feed="$1"
        local specific_version="${2//[$'\t\r\n']}"
        local package_download_link=""
        if [ $# -gt 2  ]; then
            local package_download_link="$3"
        fi
        local specific_product_version=null
    
        # Try to get the version number, using the productVersion.txt file located next to the installer file.
        local download_links=($(get_specific_product_version_url "$azure_feed" "$specific_version" true "$package_download_link")
            $(get_specific_product_version_url "$azure_feed" "$specific_version" false "$package_download_link"))
    
        for download_link in "${download_links[@]}"
        do
            say_verbose "Checking for the existence of $download_link"
    
            if machine_has "curl"
            then
                if ! specific_product_version=$(curl -sL --fail "${download_link}${feed_credential}" 2>&1); then
                    continue
                else
                    echo "${specific_product_version//[$'\t\r\n']}"
                    return 0
                fi
    
            elif machine_has "wget"
            then
                specific_product_version=$(wget -qO- "${download_link}${feed_credential}" 2>&1)
                if [ $? = 0 ]; then
                    echo "${specific_product_version//[$'\t\r\n']}"
                    return 0
                fi
            fi
        done
        
        # Getting the version number with productVersion.txt has failed. Try parsing the download link for a version number.
        say_verbose "Failed to get the version using productVersion.txt file. Download link will be parsed instead."
        specific_product_version="$(get_product_specific_version_from_download_link "$package_download_link" "$specific_version")"
        echo "${specific_product_version//[$'\t\r\n']}"
        return 0
    }
    
    # args:
    # azure_feed - $1
    # specific_version - $2
    # is_flattened - $3
    # download link - $4 (optional)
    get_specific_product_version_url() {
        eval $invocation
    
        local azure_feed="$1"
        local specific_version="$2"
        local is_flattened="$3"
        local package_download_link=""
        if [ $# -gt 3  ]; then
            local package_download_link="$4"
        fi
    
        local pvFileName="productVersion.txt"
        if [ "$is_flattened" = true ]; then
            if [ -z "$runtime" ]; then
                pvFileName="sdk-productVersion.txt"
            elif [[ "$runtime" == "dotnet" ]]; then
                pvFileName="runtime-productVersion.txt"
            else
                pvFileName="$runtime-productVersion.txt"
            fi
        fi
    
        local download_link=null
    
        if [ -z "$package_download_link" ]; then
            if [[ "$runtime" == "dotnet" ]]; then
                download_link="$azure_feed/Runtime/$specific_version/${pvFileName}"
            elif [[ "$runtime" == "aspnetcore" ]]; then
                download_link="$azure_feed/aspnetcore/Runtime/$specific_version/${pvFileName}"
            elif [ -z "$runtime" ]; then
                download_link="$azure_feed/Sdk/$specific_version/${pvFileName}"
            else
                return 1
            fi
        else
            download_link="${package_download_link%/*}/${pvFileName}"
        fi
    
        say_verbose "Constructed productVersion link: $download_link"
        echo "$download_link"
        return 0
    }
    
    # args:
    # download link - $1
    # specific version - $2
    get_product_specific_version_from_download_link()
    {
        eval $invocation
    
        local download_link="$1"
        local specific_version="$2"
        local specific_product_version="" 
    
        if [ -z "$download_link" ]; then
            echo "$specific_version"
            return 0
        fi
    
        #get filename
        filename="${download_link##*/}"
    
        #product specific version follows the product name
        #for filename 'dotnet-sdk-3.1.404-linux-x64.tar.gz': the product version is 3.1.404
        IFS='-'
        read -ra filename_elems <<< "$filename"
        count=${#filename_elems[@]}
        if [[ "$count" -gt 2 ]]; then
            specific_product_version="${filename_elems[2]}"
        else
            specific_product_version=$specific_version
        fi
        unset IFS;
        echo "$specific_product_version"
        return 0
    }
    
    # args:
    # azure_feed - $1
    # channel - $2
    # normalized_architecture - $3
    # specific_version - $4
    construct_legacy_download_link() {
        eval $invocation
    
        local azure_feed="$1"
        local channel="$2"
        local normalized_architecture="$3"
        local specific_version="${4//[$'\t\r\n']}"
    
        local distro_specific_osname
        distro_specific_osname="$(get_legacy_os_name)" || return 1
    
        local legacy_download_link=null
        if [[ "$runtime" == "dotnet" ]]; then
            legacy_download_link="$azure_feed/Runtime/$specific_version/dotnet-$distro_specific_osname-$normalized_architecture.$specific_version.tar.gz"
        elif [ -z "$runtime" ]; then
            legacy_download_link="$azure_feed/Sdk/$specific_version/dotnet-dev-$distro_specific_osname-$normalized_architecture.$specific_version.tar.gz"
        else
            return 1
        fi
    
        echo "$legacy_download_link"
        return 0
    }
    
    get_user_install_path() {
        eval $invocation
    
        if [ ! -z "${DOTNET_INSTALL_DIR:-}" ]; then
            echo "$DOTNET_INSTALL_DIR"
        else
            echo "$HOME/.dotnet"
        fi
        return 0
    }
    
    # args:
    # install_dir - $1
    resolve_installation_path() {
        eval $invocation
    
        local install_dir=$1
        if [ "$install_dir" = "<auto>" ]; then
            local user_install_path="$(get_user_install_path)"
            say_verbose "resolve_installation_path: user_install_path=$user_install_path"
            echo "$user_install_path"
            return 0
        fi
    
        echo "$install_dir"
        return 0
    }
    
    # args:
    # relative_or_absolute_path - $1
    get_absolute_path() {
        eval $invocation
    
        local relative_or_absolute_path=$1
        echo "$(cd "$(dirname "$1")" && pwd -P)/$(basename "$1")"
        return 0
    }
    
    # args:
    # override - $1 (boolean, true or false)
    get_cp_options() {
        eval $invocation
    
        local override="$1"
        local override_switch=""
    
        if [ "$override" = false ]; then
            override_switch="-n"
    
            # create temporary files to check if 'cp -u' is supported
            tmp_dir="$(mktemp -d)"
            tmp_file="$tmp_dir/testfile"
            tmp_file2="$tmp_dir/testfile2"
    
            touch "$tmp_file"
    
            # use -u instead of -n if it's available
            if cp -u "$tmp_file" "$tmp_file2" 2>/dev/null; then
                override_switch="-u"
            fi
    
            # clean up
            rm -f "$tmp_file" "$tmp_file2"
            rm -rf "$tmp_dir"
        fi
    
        echo "$override_switch"
    }
    
    # args:
    # input_files - stdin
    # root_path - $1
    # out_path - $2
    # override - $3
    copy_files_or_dirs_from_list() {
        eval $invocation
    
        local root_path="$(remove_trailing_slash "$1")"
        local out_path="$(remove_trailing_slash "$2")"
        local override="$3"
        local override_switch="$(get_cp_options "$override")"
    
        cat | uniq | while read -r file_path; do
            local path="$(remove_beginning_slash "${file_path#$root_path}")"
            local target="$out_path/$path"
            if [ "$override" = true ] || (! ([ -d "$target" ] || [ -e "$target" ])); then
                mkdir -p "$out_path/$(dirname "$path")"
                if [ -d "$target" ]; then
                    rm -rf "$target"
                fi
                cp -R $override_switch "$root_path/$path" "$target"
            fi
        done
    }
    
    # args:
    # zip_uri - $1
    get_remote_file_size() {
        local zip_uri="$1"
    
        if machine_has "curl"; then
            file_size=$(curl -sI  "$zip_uri" | grep -i content-length | awk '{ num = $2 + 0; print num }')
        elif machine_has "wget"; then
            file_size=$(wget --spider --server-response -O /dev/null "$zip_uri" 2>&1 | grep -i 'Content-Length:' | awk '{ num = $2 + 0; print num }')
        else
            say "Neither curl nor wget is available on this system."
            return
        fi
    
        if [ -n "$file_size" ]; then
            say "Remote file $zip_uri size is $file_size bytes."
            echo "$file_size"
        else
            say_verbose "Content-Length header was not extracted for $zip_uri."
            echo ""
        fi
    }
    
    # args:
    # zip_path - $1
    # out_path - $2
    # remote_file_size - $3
    extract_dotnet_package() {
        eval $invocation
    
        local zip_path="$1"
        local out_path="$2"
        local remote_file_size="$3"
    
        local temp_out_path="$(mktemp -d "$temporary_file_template")"
    
        local failed=false
        tar -xzf "$zip_path" -C "$temp_out_path" > /dev/null || failed=true
    
        local folders_with_version_regex='^.*/[0-9]+\.[0-9]+[^/]+/'
        find "$temp_out_path" -type f | grep -Eo "$folders_with_version_regex" | sort | copy_files_or_dirs_from_list "$temp_out_path" "$out_path" false
        find "$temp_out_path" -type f | grep -Ev "$folders_with_version_regex" | copy_files_or_dirs_from_list "$temp_out_path" "$out_path" "$override_non_versioned_files"
        
        validate_remote_local_file_sizes "$zip_path" "$remote_file_size"
        
        rm -rf "$temp_out_path"
        if [ -z ${keep_zip+x} ]; then
            rm -f "$zip_path" && say_verbose "Temporary archive file $zip_path was removed"
        fi
    
        if [ "$failed" = true ]; then
            say_err "Extraction failed"
            return 1
        fi
        return 0
    }
    
    # args:
    # remote_path - $1
    # disable_feed_credential - $2
    get_http_header()
    {
        eval $invocation
        local remote_path="$1"
        local disable_feed_credential="$2"
    
        local failed=false
        local response
        if machine_has "curl"; then
            get_http_header_curl $remote_path $disable_feed_credential || failed=true
        elif machine_has "wget"; then
            get_http_header_wget $remote_path $disable_feed_credential || failed=true
        else
            failed=true
        fi
        if [ "$failed" = true ]; then
            say_verbose "Failed to get HTTP header: '$remote_path'."
            return 1
        fi
        return 0
    }
    
    # args:
    # remote_path - $1
    # disable_feed_credential - $2
    get_http_header_curl() {
        eval $invocation
        local remote_path="$1"
        local disable_feed_credential="$2"
    
        remote_path_with_credential="$remote_path"
        if [ "$disable_feed_credential" = false ]; then
            remote_path_with_credential+="$feed_credential"
        fi
    
        curl_options="-I -sSL --retry 5 --retry-delay 2 --connect-timeout 15 "
        curl $curl_options "$remote_path_with_credential" 2>&1 || return 1
        return 0
    }
    
    # args:
    # remote_path - $1
    # disable_feed_credential - $2
    get_http_header_wget() {
        eval $invocation
        local remote_path="$1"
        local disable_feed_credential="$2"
        local wget_options="-q -S --spider --tries 5 "
    
        local wget_options_extra=''
    
        # Test for options that aren't supported on all wget implementations.
        if [[ $(wget -h 2>&1 | grep -E 'waitretry|connect-timeout') ]]; then
            wget_options_extra="--waitretry 2 --connect-timeout 15 "
        else
            say "wget extra options are unavailable for this environment"
        fi
    
        remote_path_with_credential="$remote_path"
        if [ "$disable_feed_credential" = false ]; then
            remote_path_with_credential+="$feed_credential"
        fi
    
        wget $wget_options $wget_options_extra "$remote_path_with_credential" 2>&1
    
        return $?
    }
    
    # args:
    # remote_path - $1
    # [out_path] - $2 - stdout if not provided
    download() {
        eval $invocation
    
        local remote_path="$1"
        local out_path="${2:-}"
    
        if [[ "$remote_path" != "http"* ]]; then
            cp "$remote_path" "$out_path"
            return $?
        fi
    
        local failed=false
        local attempts=0
        while [ $attempts -lt 3 ]; do
            attempts=$((attempts+1))
            failed=false
            if machine_has "curl"; then
                downloadcurl "$remote_path" "$out_path" || failed=true
            elif machine_has "wget"; then
                downloadwget "$remote_path" "$out_path" || failed=true
            else
                say_err "Missing dependency: neither curl nor wget was found."
                exit 1
            fi
    
            if [ "$failed" = false ] || [ $attempts -ge 3 ] || { [ -n "${http_code-}" ] && [ "${http_code}" = "404" ]; }; then
                break
            fi
    
            say "Download attempt #$attempts has failed: ${http_code-} ${download_error_msg-}"
            say "Attempt #$((attempts+1)) will start in $((attempts*10)) seconds."
            sleep $((attempts*10))
        done
    
        if [ "$failed" = true ]; then
            say_verbose "Download failed: $remote_path"
            return 1
        fi
        return 0
    }
    
    # Updates global variables $http_code and $download_error_msg
    downloadcurl() {
        eval $invocation
        unset http_code
        unset download_error_msg
        local remote_path="$1"
        local out_path="${2:-}"
        # Append feed_credential as late as possible before calling curl to avoid logging feed_credential
        # Avoid passing URI with credentials to functions: note, most of them echoing parameters of invocation in verbose output.
        local remote_path_with_credential="${remote_path}${feed_credential}"
        local curl_options="--retry 20 --retry-delay 2 --connect-timeout 15 -sSL -f --create-dirs "
        local curl_exit_code=0;
        if [ -z "$out_path" ]; then
            curl_output=$(curl $curl_options "$remote_path_with_credential" 2>&1)
            curl_exit_code=$?
            echo "$curl_output"
        else
            curl_output=$(curl $curl_options -o "$out_path" "$remote_path_with_credential" 2>&1)
            curl_exit_code=$?
        fi
    
        # Regression in curl causes curl with --retry to return a 0 exit code even when it fails to download a file - https://github.com/curl/curl/issues/17554
        if [ $curl_exit_code -eq 0 ] && echo "$curl_output" | grep -q "^curl: ([0-9]*) "; then
            curl_exit_code=$(echo "$curl_output" | sed 's/curl: (\([0-9]*\)).*/\1/')
        fi
    
        if [ $curl_exit_code -gt 0 ]; then
            download_error_msg="Unable to download $remote_path."
            # Check for curl timeout codes
            if [[ $curl_exit_code == 7 || $curl_exit_code == 28 ]]; then
                download_error_msg+=" Failed to reach the server: connection timeout."
            else
                local disable_feed_credential=false
                local response=$(get_http_header_curl $remote_path $disable_feed_credential)
                http_code=$( echo "$response" | awk '/^HTTP/{print $2}' | tail -1 )
                if  [[ ! -z $http_code && $http_code != 2* ]]; then
                    download_error_msg+=" Returned HTTP status code: $http_code."
                fi
            fi
            say_verbose "$download_error_msg"
            return 1
        fi
        return 0
    }
    
    
    # Updates global variables $http_code and $download_error_msg
    downloadwget() {
        eval $invocation
        unset http_code
        unset download_error_msg
        local remote_path="$1"
        local out_path="${2:-}"
        # Append feed_credential as late as possible before calling wget to avoid logging feed_credential
        local remote_path_with_credential="${remote_path}${feed_credential}"
        local wget_options="--tries 20 "
    
        local wget_options_extra=''
        local wget_result=''
    
        # Test for options that aren't supported on all wget implementations.
        if [[ $(wget -h 2>&1 | grep -E 'waitretry|connect-timeout') ]]; then
            wget_options_extra="--waitretry 2 --connect-timeout 15 "
        else
            say "wget extra options are unavailable for this environment"
        fi
    
        if [ -z "$out_path" ]; then
            wget -q $wget_options $wget_options_extra -O - "$remote_path_with_credential" 2>&1
            wget_result=$?
        else
            wget $wget_options $wget_options_extra -O "$out_path" "$remote_path_with_credential" 2>&1
            wget_result=$?
        fi
    
        if [[ $wget_result != 0 ]]; then
            local disable_feed_credential=false
            local response=$(get_http_header_wget $remote_path $disable_feed_credential)
            http_code=$( echo "$response" | awk '/^  HTTP/{print $2}' | tail -1 )
            download_error_msg="Unable to download $remote_path."
            if  [[ ! -z $http_code && $http_code != 2* ]]; then
                download_error_msg+=" Returned HTTP status code: $http_code."
            # wget exit code 4 stands for network-issue
            elif [[ $wget_result == 4 ]]; then
                download_error_msg+=" Failed to reach the server: connection timeout."
            fi
            say_verbose "$download_error_msg"
            return 1
        fi
    
        return 0
    }
    
    get_download_link_from_aka_ms() {
        eval $invocation
    
        #quality is not supported for LTS or STS channel
        #STS maps to current
        if [[ ! -z "$normalized_quality"  && ("$normalized_channel" == "LTS" || "$normalized_channel" == "STS") ]]; then
            normalized_quality=""
            say_warning "Specifying quality for STS or LTS channel is not supported, the quality will be ignored."
        fi
    
        say_verbose "Retrieving primary payload URL from aka.ms for channel: '$normalized_channel', quality: '$normalized_quality', product: '$normalized_product', os: '$normalized_os', architecture: '$normalized_architecture'." 
    
        #construct aka.ms link
        aka_ms_link="https://aka.ms/dotnet"
        if  [ "$internal" = true ]; then
            aka_ms_link="$aka_ms_link/internal"
        fi
        aka_ms_link="$aka_ms_link/$normalized_channel"
        if [[ ! -z "$normalized_quality" ]]; then
            aka_ms_link="$aka_ms_link/$normalized_quality"
        fi
        aka_ms_link="$aka_ms_link/$normalized_product-$normalized_os-$normalized_architecture.tar.gz"
        say_verbose "Constructed aka.ms link: '$aka_ms_link'."
    
        #get HTTP response
        #do not pass credentials as a part of the $aka_ms_link and do not apply credentials in the get_http_header function
        #otherwise the redirect link would have credentials as well
        #it would result in applying credentials twice to the resulting link and thus breaking it, and in echoing credentials to the output as a part of redirect link
        disable_feed_credential=true
        response="$(get_http_header $aka_ms_link $disable_feed_credential)"
    
        say_verbose "Received response: $response"
        # Get results of all the redirects.
        http_codes=$( echo "$response" | awk '$1 ~ /^HTTP/ {print $2}' )
        # Allow intermediate 301 redirects and tolerate proxy-injected 200s
        broken_redirects=$( echo "$http_codes" | sed '$d' | grep -vE '^(301|200)$' )
        # The response may end without final code 2xx/4xx/5xx somehow, e.g. network restrictions on www.bing.com causes redirecting to bing.com fails with connection refused.
        # In this case it should not exclude the last.
        last_http_code=$(  echo "$http_codes" | tail -n 1 )
        if ! [[ $last_http_code =~ ^(2|4|5)[0-9][0-9]$ ]]; then
            broken_redirects=$( echo "$http_codes" | grep -vE '^(301|200)$' )
        fi
    
        # All HTTP codes are 301 (Moved Permanently), the redirect link exists.
        if [[ -z "$broken_redirects" ]]; then
            aka_ms_download_link=$( echo "$response" | awk '$1 ~ /^Location/{print $2}' | tail -1 | tr -d '\r')
    
            if [[ -z "$aka_ms_download_link" ]]; then
                say_verbose "The aka.ms link '$aka_ms_link' is not valid: failed to get redirect location."
                return 1
            fi
    
            say_verbose "The redirect location retrieved: '$aka_ms_download_link'."
            return 0
        else
            say_verbose "The aka.ms link '$aka_ms_link' is not valid: received HTTP code: $(echo "$broken_redirects" | paste -sd "," -)."
            return 1
        fi
    }
    
    get_feeds_to_use()
    {
        feeds=(
        "https://builds.dotnet.microsoft.com/dotnet"
        "https://ci.dot.net/public"
        )
    
        if [[ -n "$azure_feed" ]]; then
            feeds=("$azure_feed")
        fi
    
        if [[ -n "$uncached_feed" ]]; then
            feeds=("$uncached_feed")
        fi
    }
    
    # THIS FUNCTION MAY EXIT (if the determined version is already installed).
    generate_download_links() {
    
        download_links=()
        specific_versions=()
        effective_versions=()
        link_types=()
    
        # If generate_akams_links returns false, no fallback to old links. Just terminate.
        # This function may also 'exit' (if the determined version is already installed).
        generate_akams_links || return
    
        # Check other feeds only if we haven't been able to find an aka.ms link.
        if [[ "${#download_links[@]}" -lt 1 ]]; then
            for feed in ${feeds[@]}
            do
                # generate_regular_links may also 'exit' (if the determined version is already installed).
                generate_regular_links $feed || return
            done
        fi
    
        if [[ "${#download_links[@]}" -eq 0 ]]; then
            say_err "Failed to resolve the exact version number."
            return 1
        fi
    
        say_verbose "Generated ${#download_links[@]} links."
        for link_index in ${!download_links[@]}
        do
            say_verbose "Link $link_index: ${link_types[$link_index]}, ${effective_versions[$link_index]}, ${download_links[$link_index]}"
        done
    }
    
    # THIS FUNCTION MAY EXIT (if the determined version is already installed).
    generate_akams_links() {
        local valid_aka_ms_link=true;
    
        normalized_version="$(to_lowercase "$version")"
        if [[ "$normalized_version" != "latest" ]] && [ -n "$normalized_quality" ]; then
            say_err "Quality and Version options are not allowed to be specified simultaneously. See https://learn.microsoft.com/dotnet/core/tools/dotnet-install-script#options for details."
            return 1
        fi
    
        if [[ -n "$json_file" || "$normalized_version" != "latest" ]]; then
            # aka.ms links are not needed when exact version is specified via command or json file
            return
        fi
    
        get_download_link_from_aka_ms || valid_aka_ms_link=false
    
        if [[ "$valid_aka_ms_link" == true ]]; then
            say_verbose "Retrieved primary payload URL from aka.ms link: '$aka_ms_download_link'."
            say_verbose "Downloading using legacy url will not be attempted."
    
            download_link=$aka_ms_download_link
    
            #get version from the path
            IFS='/'
            read -ra pathElems <<< "$download_link"
            count=${#pathElems[@]}
            specific_version="${pathElems[count-2]}"
            unset IFS;
            say_verbose "Version: '$specific_version'."
    
            #Retrieve effective version
            effective_version="$(get_specific_product_version "$azure_feed" "$specific_version" "$download_link")"
    
            # Add link info to arrays
            download_links+=($download_link)
            specific_versions+=($specific_version)
            effective_versions+=($effective_version)
            link_types+=("aka.ms")
    
            #  Check if the SDK version is already installed.
            if [[ "$dry_run" != true ]] && is_dotnet_package_installed "$install_root" "$asset_relative_path" "$effective_version"; then
                say "$asset_name with version '$effective_version' is already installed."
                exit 0
            fi
    
            return 0
        fi
    
        # if quality is specified - exit with error - there is no fallback approach
        if [ ! -z "$normalized_quality" ]; then
            say_err "Failed to locate the latest version in the channel '$normalized_channel' with '$normalized_quality' quality for '$normalized_product', os: '$normalized_os', architecture: '$normalized_architecture'."
            say_err "Refer to: https://aka.ms/dotnet-os-lifecycle for information on .NET Core support."
            return 1
        fi
        say_verbose "Falling back to latest.version file approach."
    }
    
    # THIS FUNCTION MAY EXIT (if the determined version is already installed)
    # args:
    # feed - $1
    generate_regular_links() {
        local feed="$1"
        local valid_legacy_download_link=true
    
        specific_version=$(get_specific_version_from_version "$feed" "$channel" "$normalized_architecture" "$version" "$json_file") || specific_version='0'
    
        if [[ "$specific_version" == '0' ]]; then
            say_verbose "Failed to resolve the specific version number using feed '$feed'"
            return
        fi
    
        effective_version="$(get_specific_product_version "$feed" "$specific_version")"
        say_verbose "specific_version=$specific_version"
    
        download_link="$(construct_download_link "$feed" "$channel" "$normalized_architecture" "$specific_version" "$normalized_os")"
        say_verbose "Constructed primary named payload URL: $download_link"
    
        # Add link info to arrays
        download_links+=($download_link)
        specific_versions+=($specific_version)
        effective_versions+=($effective_version)
        link_types+=("primary")
    
        legacy_download_link="$(construct_legacy_download_link "$feed" "$channel" "$normalized_architecture" "$specific_version")" || valid_legacy_download_link=false
    
        if [ "$valid_legacy_download_link" = true ]; then
            say_verbose "Constructed legacy named payload URL: $legacy_download_link"
        
            download_links+=($legacy_download_link)
            specific_versions+=($specific_version)
            effective_versions+=($effective_version)
            link_types+=("legacy")
        else
            legacy_download_link=""
            say_verbose "Could not construct a legacy_download_link; omitting..."
        fi
    
        #  Check if the SDK version is already installed.
        if [[ "$dry_run" != true ]] && is_dotnet_package_installed "$install_root" "$asset_relative_path" "$effective_version"; then
            say "$asset_name with version '$effective_version' is already installed."
            exit 0
        fi
    }
    
    print_dry_run() {
    
        say "Payload URLs:"
    
        for link_index in "${!download_links[@]}"
            do
                say "URL #$link_index - ${link_types[$link_index]}: ${download_links[$link_index]}"
        done
    
        resolved_version=${specific_versions[0]}
        repeatable_command="./$script_name --version "\""$resolved_version"\"" --install-dir "\""$install_root"\"" --architecture "\""$normalized_architecture"\"" --os "\""$normalized_os"\"""
        
        if [ ! -z "$normalized_quality" ]; then
            repeatable_command+=" --quality "\""$normalized_quality"\"""
        fi
    
        if [[ "$runtime" == "dotnet" ]]; then
            repeatable_command+=" --runtime "\""dotnet"\"""
        elif [[ "$runtime" == "aspnetcore" ]]; then
            repeatable_command+=" --runtime "\""aspnetcore"\"""
        fi
    
        repeatable_command+="$non_dynamic_parameters"
    
        if [ -n "$feed_credential" ]; then
            repeatable_command+=" --feed-credential "\""<feed_credential>"\"""
        fi
    
        say "Repeatable invocation: $repeatable_command"
    }
    
    calculate_vars() {
        eval $invocation
    
        script_name=$(basename "$0")
        normalized_architecture="$(get_normalized_architecture_from_architecture "$architecture")"
        say_verbose "Normalized architecture: '$normalized_architecture'."
        normalized_os="$(get_normalized_os "$user_defined_os")"
        say_verbose "Normalized OS: '$normalized_os'."
        normalized_quality="$(get_normalized_quality "$quality")"
        say_verbose "Normalized quality: '$normalized_quality'."
        normalized_channel="$(get_normalized_channel "$channel")"
        say_verbose "Normalized channel: '$normalized_channel'."
        normalized_product="$(get_normalized_product "$runtime")"
        say_verbose "Normalized product: '$normalized_product'."
        install_root="$(resolve_installation_path "$install_dir")"
        say_verbose "InstallRoot: '$install_root'."
    
        normalized_architecture="$(get_normalized_architecture_for_specific_sdk_version "$version" "$normalized_channel" "$normalized_architecture")"
    
        if [[ "$runtime" == "dotnet" ]]; then
            asset_relative_path="shared/Microsoft.NETCore.App"
            asset_name=".NET Core Runtime"
        elif [[ "$runtime" == "aspnetcore" ]]; then
            asset_relative_path="shared/Microsoft.AspNetCore.App"
            asset_name="ASP.NET Core Runtime"
        elif [ -z "$runtime" ]; then
            asset_relative_path="sdk"
            asset_name=".NET Core SDK"
        fi
    
        get_feeds_to_use
    }
    
    install_dotnet() {
        eval $invocation
        local download_failed=false
        local download_completed=false
        local remote_file_size=0
    
        mkdir -p "$install_root"
        zip_path="${zip_path:-$(mktemp "$temporary_file_template")}"
        say_verbose "Archive path: $zip_path"
    
        for link_index in "${!download_links[@]}"
        do
            download_link="${download_links[$link_index]}"
            specific_version="${specific_versions[$link_index]}"
            effective_version="${effective_versions[$link_index]}"
            link_type="${link_types[$link_index]}"
    
            say "Attempting to download using $link_type link $download_link"
    
            # The download function will set variables $http_code and $download_error_msg in case of failure.
            download_failed=false
            download "$download_link" "$zip_path" 2>&1 || download_failed=true
    
            if [ "$download_failed" = true ]; then
                case ${http_code-} in
                404)
                    say "The resource at $link_type link '$download_link' is not available."
                    ;;
                *)
                    say "Failed to download $link_type link '$download_link': ${http_code-} ${download_error_msg-}"
                    ;;
                esac
                rm -f "$zip_path" 2>&1 && say_verbose "Temporary archive file $zip_path was removed"
            else
                download_completed=true
                break
            fi
        done
    
        if [[ "$download_completed" == false ]]; then
            say_err "Could not find \`$asset_name\` with version = $specific_version"
            say_err "Refer to: https://aka.ms/dotnet-os-lifecycle for information on .NET Core support"
            return 1
        fi
    
        remote_file_size="$(get_remote_file_size "$download_link")"
    
        say "Extracting archive from $download_link"
        extract_dotnet_package "$zip_path" "$install_root" "$remote_file_size" || return 1
    
        #  Check if the SDK version is installed; if not, fail the installation.
        # if the version contains "RTM" or "servicing"; check if a 'release-type' SDK version is installed.
        if [[ $specific_version == *"rtm"* || $specific_version == *"servicing"* ]]; then
            IFS='-'
            read -ra verArr <<< "$specific_version"
            release_version="${verArr[0]}"
            unset IFS;
            say_verbose "Checking installation: version = $release_version"
            if is_dotnet_package_installed "$install_root" "$asset_relative_path" "$release_version"; then
                say "Installed version is $effective_version"
                return 0
            fi
        fi
    
        #  Check if the standard SDK version is installed.
        say_verbose "Checking installation: version = $effective_version"
        if is_dotnet_package_installed "$install_root" "$asset_relative_path" "$effective_version"; then
            say "Installed version is $effective_version"
            return 0
        fi
    
        # Version verification failed. More likely something is wrong either with the downloaded content or with the verification algorithm.
        say_err "Failed to verify the version of installed \`$asset_name\`.\nInstallation source: $download_link.\nInstallation location: $install_root.\nReport the bug at https://github.com/dotnet/install-scripts/issues."
        say_err "\`$asset_name\` with version = $effective_version failed to install with an error."
        return 1
    }
    
    args=("$@")
    
    local_version_file_relative_path="/.version"
    bin_folder_relative_path=""
    temporary_file_template="${TMPDIR:-/tmp}/dotnet.XXXXXXXXX"
    
    channel="LTS"
    version="Latest"
    json_file=""
    install_dir="<auto>"
    architecture="<auto>"
    dry_run=false
    no_path=false
    azure_feed=""
    uncached_feed=""
    feed_credential=""
    verbose=false
    runtime=""
    runtime_id=""
    quality=""
    internal=false
    override_non_versioned_files=true
    non_dynamic_parameters=""
    user_defined_os=""
    
    while [ $# -ne 0 ]
    do
        name="$1"
        case "$name" in
            -c|--channel|-[Cc]hannel)
                shift
                channel="$1"
                ;;
            -v|--version|-[Vv]ersion)
                shift
                version="$1"
                ;;
            -q|--quality|-[Qq]uality)
                shift
                quality="$1"
                ;;
            --internal|-[Ii]nternal)
                internal=true
                non_dynamic_parameters+=" $name"
                ;;
            -i|--install-dir|-[Ii]nstall[Dd]ir)
                shift
                install_dir="$1"
                ;;
            --arch|--architecture|-[Aa]rch|-[Aa]rchitecture)
                shift
                architecture="$1"
                ;;
            --os|-[Oo][SS])
                shift
                user_defined_os="$1"
                ;;
            --shared-runtime|-[Ss]hared[Rr]untime)
                say_warning "The --shared-runtime flag is obsolete and may be removed in a future version of this script. The recommended usage is to specify '--runtime dotnet'."
                if [ -z "$runtime" ]; then
                    runtime="dotnet"
                fi
                ;;
            --runtime|-[Rr]untime)
                shift
                runtime="$1"
                if [[ "$runtime" != "dotnet" ]] && [[ "$runtime" != "aspnetcore" ]]; then
                    say_err "Unsupported value for --runtime: '$1'. Valid values are 'dotnet' and 'aspnetcore'."
                    if [[ "$runtime" == "windowsdesktop" ]]; then
                        say_err "WindowsDesktop archives are manufactured for Windows platforms only."
                    fi
                    exit 1
                fi
                ;;
            --dry-run|-[Dd]ry[Rr]un)
                dry_run=true
                ;;
            --no-path|-[Nn]o[Pp]ath)
                no_path=true
                non_dynamic_parameters+=" $name"
                ;;
            --verbose|-[Vv]erbose)
                verbose=true
                non_dynamic_parameters+=" $name"
                ;;
            --azure-feed|-[Aa]zure[Ff]eed)
                shift
                azure_feed="$1"
                non_dynamic_parameters+=" $name "\""$1"\"""
                ;;
            --uncached-feed|-[Uu]ncached[Ff]eed)
                shift
                uncached_feed="$1"
                non_dynamic_parameters+=" $name "\""$1"\"""
                ;;
            --feed-credential|-[Ff]eed[Cc]redential)
                shift
                feed_credential="$1"
                #feed_credential should start with "?", for it to be added to the end of the link.
                #adding "?" at the beginning of the feed_credential if needed.
                [[ -z "$(echo $feed_credential)" ]] || [[ $feed_credential == \?* ]] || feed_credential="?$feed_credential"
                ;;
            --runtime-id|-[Rr]untime[Ii]d)
                shift
                runtime_id="$1"
                non_dynamic_parameters+=" $name "\""$1"\"""
                say_warning "Use of --runtime-id is obsolete and should be limited to the versions below 2.1. To override architecture, use --architecture option instead. To override OS, use --os option instead."
                ;;
            --jsonfile|-[Jj][Ss]on[Ff]ile)
                shift
                json_file="$1"
                ;;
            --skip-non-versioned-files|-[Ss]kip[Nn]on[Vv]ersioned[Ff]iles)
                override_non_versioned_files=false
                non_dynamic_parameters+=" $name"
                ;;
            --keep-zip|-[Kk]eep[Zz]ip)
                keep_zip=true
                non_dynamic_parameters+=" $name"
                ;;
            --zip-path|-[Zz]ip[Pp]ath)
                shift
                zip_path="$1"
                ;;
            -?|--?|-h|--help|-[Hh]elp)
                script_name="dotnet-install.sh"
                echo ".NET Tools Installer"
                echo "Usage:"
                echo "       # Install a .NET SDK of a given Quality from a given Channel"
                echo "       $script_name [-c|--channel <CHANNEL>] [-q|--quality <QUALITY>]"
                echo "       # Install a .NET SDK of a specific public version"
                echo "       $script_name [-v|--version <VERSION>]"
                echo "       $script_name -h|-?|--help"
                echo ""
                echo "$script_name is a simple command line interface for obtaining dotnet cli."
                echo "    Note that the intended use of this script is for Continuous Integration (CI) scenarios, where:"
                echo "    - The SDK needs to be installed without user interaction and without admin rights."
                echo "    - The SDK installation doesn't need to persist across multiple CI runs."
                echo "    To set up a development environment or to run apps, use installers rather than this script. Visit https://dotnet.microsoft.com/download to get the installer."
                echo ""
                echo "Options:"
                echo "  -c,--channel <CHANNEL>         Download from the channel specified, Defaults to \`$channel\`."
                echo "      -Channel"
                echo "          Possible values:"
                echo "          - STS - the most recent Standard Term Support release"
                echo "          - LTS - the most recent Long Term Support release"
                echo "          - 2-part version in a format A.B - represents a specific release"
                echo "              examples: 2.0; 1.0"
                echo "          - 3-part version in a format A.B.Cxx - represents a specific SDK release"
                echo "              examples: 5.0.1xx, 5.0.2xx."
                echo "              Supported since 5.0 release"
                echo "          Warning: Value 'Current' is deprecated for the Channel parameter. Use 'STS' instead."
                echo "          Note: The version parameter overrides the channel parameter when any version other than 'latest' is used."
                echo "  -v,--version <VERSION>         Use specific VERSION, Defaults to \`$version\`."
                echo "      -Version"
                echo "          Possible values:"
                echo "          - latest - the latest build on specific channel"
                echo "          - 3-part version in a format A.B.C - represents specific version of build"
                echo "              examples: 2.0.0-preview2-006120; 1.1.0"
                echo "  -q,--quality <quality>         Download the latest build of specified quality in the channel."
                echo "      -Quality"
                echo "          The possible values are: daily, preview, GA."
                echo "          Works only in combination with channel. Not applicable for STS and LTS channels and will be ignored if those channels are used." 
                echo "          Supported since 5.0 release." 
                echo "          Note: The version parameter overrides the channel parameter when any version other than 'latest' is used, and therefore overrides the quality."
                echo "  --internal,-Internal               Download internal builds. Requires providing credentials via --feed-credential parameter."
                echo "  --feed-credential <FEEDCREDENTIAL> Token to access Azure feed. Used as a query string to append to the Azure feed."
                echo "      -FeedCredential                This parameter typically is not specified."
                echo "  -i,--install-dir <DIR>             Install under specified location (see Install Location below)"
                echo "      -InstallDir"
                echo "  --architecture <ARCHITECTURE>      Architecture of dotnet binaries to be installed, Defaults to \`$architecture\`."
                echo "      --arch,-Architecture,-Arch"
                echo "          Possible values: x64, arm, arm64, s390x, ppc64le and loongarch64"
                echo "  --os <system>                    Specifies operating system to be used when selecting the installer."
                echo "          Overrides the OS determination approach used by the script. Supported values: osx, linux, linux-musl, freebsd, rhel.6."
                echo "          In case any other value is provided, the platform will be determined by the script based on machine configuration."
                echo "          Not supported for legacy links. Use --runtime-id to specify platform for legacy links."
                echo "          Refer to: https://aka.ms/dotnet-os-lifecycle for more information."
                echo "  --runtime <RUNTIME>                Installs a shared runtime only, without the SDK."
                echo "      -Runtime"
                echo "          Possible values:"
                echo "          - dotnet     - the Microsoft.NETCore.App shared runtime"
                echo "          - aspnetcore - the Microsoft.AspNetCore.App shared runtime"
                echo "  --dry-run,-DryRun                  Do not perform installation. Display download link."
                echo "  --no-path, -NoPath                 Do not set PATH for the current process."
                echo "  --verbose,-Verbose                 Display diagnostics information."
                echo "  --azure-feed,-AzureFeed            For internal use only."
                echo "                                     Allows using a different storage to download SDK archives from."
                echo "  --uncached-feed,-UncachedFeed      For internal use only."
                echo "                                     Allows using a different storage to download SDK archives from."
                echo "  --skip-non-versioned-files         Skips non-versioned files if they already exist, such as the dotnet executable."
                echo "      -SkipNonVersionedFiles"
                echo "  --jsonfile <JSONFILE>              Determines the SDK version from a user specified global.json file."
                echo "                                     Note: global.json must have a value for 'SDK:Version'"
                echo "  --keep-zip,-KeepZip                If set, downloaded file is kept."
                echo "  --zip-path, -ZipPath               If set, downloaded file is stored at the specified path."
                echo "  -?,--?,-h,--help,-Help             Shows this help message"
                echo ""
                echo "Install Location:"
                echo "  Location is chosen in following order:"
                echo "    - --install-dir option"
                echo "    - Environmental variable DOTNET_INSTALL_DIR"
                echo "    - $HOME/.dotnet"
                exit 0
                ;;
            *)
                say_err "Unknown argument \`$name\`"
                exit 1
                ;;
        esac
    
        shift
    done
    
    say_verbose "Note that the intended use of this script is for Continuous Integration (CI) scenarios, where:"
    say_verbose "- The SDK needs to be installed without user interaction and without admin rights."
    say_verbose "- The SDK installation doesn't need to persist across multiple CI runs."
    say_verbose "To set up a development environment or to run apps, use installers rather than this script. Visit https://dotnet.microsoft.com/download to get the installer.\n"
    
    if [ "$internal" = true ] && [ -z "$(echo $feed_credential)" ]; then
        message="Provide credentials via --feed-credential parameter."
        if [ "$dry_run" = true ]; then
            say_warning "$message"
        else
            say_err "$message"
            exit 1
        fi
    fi
    
    check_min_reqs
    calculate_vars
    # generate_regular_links call below will 'exit' if the determined version is already installed.
    generate_download_links
    
    if [[ "$dry_run" = true ]]; then
        print_dry_run
        exit 0
    fi
    
    install_dotnet
    
    bin_path="$(get_absolute_path "$(combine_paths "$install_root" "$bin_folder_relative_path")")"
    if [ "$no_path" = false ]; then
        say "Adding to current process PATH: \`$bin_path\`. Note: This change will be visible only when sourcing script."
        export PATH="$bin_path":"$PATH"
    else
        say "Binaries of dotnet can be found in $bin_path"
    fi
    
    say "Note that the script does not resolve dependencies during installation."
    say "To check the list of dependencies, go to https://learn.microsoft.com/dotnet/core/install, select your operating system and check the \"Dependencies\" section."
    say "Installation finished successfully."
    

     

     

  2. 用脚本安装 .NET 6 ASP.NET Core Runtime
    ./dotnet-install.sh --channel 6.0 --runtime aspnetcore --arch arm
    

     

    如果你想包含 基础 .NET Runtime + ASP.NET Core

    ./dotnet-install.sh --channel 6.0 --runtime aspnetcore --arch arm
    

    如果你只需要控制台运行时:

    ./dotnet-install.sh --channel 6.0 --runtime dotnet --arch arm
    

    安装位置默认是 ~/.dotnet,你可以在命令里加 --install-dir /opt/dotnet 来指定全局目录。

  3. 安装完成后让系统知道 dotnet 在哪里:
    export DOTNET_ROOT=$HOME/.dotnet
    export PATH=$PATH:$HOME/.dotnet
    

    你可以把上面两行添加到 ~/.bashrc / ~/.profile 最后保证永久生效。

  4. 可通过reboot命令重启,确认安装是否成功:
    dotnet --list-runtimes
    

     

方法 2 — 手动下载 .NET 6 ARM32 二进制包

微软官网提供带有 ARM32 运行时的 tar 包,你可以:

  1. 下载对应 ARM32 版本:

    • .NET 6.0 runtime ARM32: 官方下载列表有 ARM32 架构的运行时(包括 ASP.NET Core Runtime 和基础 Runtime)。

  2. 解压到某个目录,例如:

    mkdir -p /opt/dotnet6 tar -C /opt/dotnet6 -xzf aspnetcore-runtime-6.0.33-linux-arm.tar.gz

     

  3. 添加到 PATH:

    export DOTNET_ROOT=/opt/dotnet6 export PATH=$PATH:/opt/dotnet6

     

    然后 dotnet --info 验证。

 这种方式手动管理更灵活,但需要手动维护更新。

注意事项(非常关键)

 apt 官方仓库 不支持 ARM32 6.0

Microsoft 在 Debian/Ubuntu 官方 apt 源只发布 x64 和 ARM64 包。ARM32 版本只能用 install‑script 或手动直接下载。

下面是一键安装 .NET 6 ARM32 + 配置 systemd + Nginx 反代的完整脚本

适用于你的玩客云 / Armbian(ARMv7 / 32 位,1 GB RAM),功能包括:

  • 安装 .NET 6 ARM32 运行时

  • 配置 systemd 开机自启服务

  • 安装 Nginx 并配置反向代理

脚本尽量低内存优化,适合 1 GB RAM 的设备。

#!/bin/bash
# 一键安装 .NET 6 ARM32 + systemd + Nginx 反向代理
# 适用于 Armbian / ARMv7 (玩客云)
# 使用前请替换 MyApp 路径和域名/IP

set -e

APP_NAME="MyApp"                          # ASP.NET Core 发布后的文件夹名
APP_DIR="$HOME/$APP_NAME"                 # ASP.NET Core 发布目录
DOTNET_DIR="$HOME/.dotnet"                # dotnet 安装目录
SERVICE_FILE="/etc/systemd/system/$APP_NAME.service"
NGINX_SITE="/etc/nginx/sites-available/$APP_NAME"

echo "==> 安装依赖"
sudo apt update
sudo apt install -y wget tar nginx

echo "==> 下载并安装 .NET 6 ARM32 运行时"
mkdir -p $DOTNET_DIR
wget https://dot.net/v1/dotnet-install.sh -O $HOME/dotnet-install.sh
chmod +x $HOME/dotnet-install.sh
$HOME/dotnet-install.sh --channel 6.0 --runtime aspnetcore --arch arm --install-dir $DOTNET_DIR

# 设置环境变量
if ! grep -q 'DOTNET_ROOT' ~/.bashrc; then
    echo "export DOTNET_ROOT=$DOTNET_DIR" >> ~/.bashrc
    echo 'export PATH=$PATH:$DOTNET_ROOT' >> ~/.bashrc
fi
export DOTNET_ROOT=$DOTNET_DIR
export PATH=$PATH:$DOTNET_ROOT

echo "==> 创建 systemd 服务"
sudo tee $SERVICE_FILE > /dev/null <<EOL
[Unit]
Description=$APP_NAME ASP.NET Core App
After=network.target

[Service]
WorkingDirectory=$APP_DIR
ExecStart=$DOTNET_DIR/dotnet $APP_DIR/$APP_NAME.dll
Restart=always
Environment=DOTNET_GC_CONSERVE_MEMORY=1
Environment=DOTNET_GC_HEAP_HARD_LIMIT=200M
Environment=ASPNETCORE_ENVIRONMENT=Production

[Install]
WantedBy=multi-user.target
EOL

sudo systemctl daemon-reload
sudo systemctl enable $APP_NAME
sudo systemctl start $APP_NAME

echo "==> 配置 Nginx 反向代理"
sudo tee $NGINX_SITE > /dev/null <<EOL
server {
    listen 80;
    server_name _;  # 可以改成你的域名或IP

    location / {
        proxy_pass http://127.0.0.1:5000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade \$http_upgrade;
        proxy_set_header Connection keep-alive;
        proxy_set_header Host \$host;
        proxy_cache_bypass \$http_upgrade;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto \$scheme;
    }
}
EOL

sudo ln -sf $NGINX_SITE /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

echo "==> 安装完成"
echo "访问 http://你的玩客云IP/ 即可看到 ASP.NET Core MVC 网站"
echo "如果需要修改 App 路径,请编辑 APP_NAME 和 APP_DIR 变量"

 

使用方法

直接将上面的代码复制到nano打开的文件里,不要在windows上新建记事本然后上传。

解决办法:

sudo nano /etc/apt/sources.list

注释掉带bullseye-backports的源,或者注释掉

#deb http://deb.debian.org/debian bullseye-backports main contrib non-free
  1. 把你的 ASP.NET Core MVC 发布目录 放到 $HOME/MyApp(或者修改脚本 APP_DIR

  2. 给脚本执行权限:

  3. 注意:也可以直接写具体的路径
    APP_NAME="websitename"                 # 任意名字,只是 systemd 服务名
    APP_DIR="/var/www/websitename"         # 你的实际发布目录
    

     

  4. 还需要设置目录权限
    sudo chown -R $USER:$USER /var/www/websitename
    sudo chmod -R 755 /var/www/websitename
    

    systemd 配置自动更新 systemd 会读取 $APP_DIR/$APP_NAME.dll,所以只要保持 DLL 名字和目录对应,服务就能正常启动:

    [Service]
    WorkingDirectory=/var/www/websitename
    ExecStart=$DOTNET_DIR/dotnet /var/www/websitename/websitename.dll
    
  5. 运行脚本:

    ./install_dotnet6_arm32.sh
  6. 查看服务状态:

    sudo systemctl status MyApp
    sudo journalctl -u MyApp -f
  7. 浏览器访问:

    http://玩客云IP/
    
    

    配置文件修改(可选):

    sudo nano /etc/nginx/sites-enabled/websitename
    
    
    server {
        listen 80;
        server_name 192.168.101.11;  # 可以改成你的域名或IP
    root /var/www/websitename;
        index index.html;
        location / {
            proxy_pass http://127.0.0.1:5000;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection keep-alive;
            proxy_set_header Host $host;
            proxy_cache_bypass $http_upgrade;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
        }
    

     

特点

  • 安装 .NET 6 ARM32 Runtime(非 apt,适合 ARMv7)

  • 自动配置 systemd 开机自启

  • 配置 Nginx 反向代理,Kestrel 只监听本地 5000 端口

  • 内存优化(GC 限制,低内存友好)

  • 完全适合玩客云 ARMv7 + 1 GB RAM

最后是重启服务命令

sudo systemctl daemon-reload
sudo systemctl restart websitename.service
sudo systemctl status websitename.service

最好将默认站点禁用或者删除

sudo unlink /etc/nginx/sites-enabled/default
sudo systemctl reload nginx

 

已经安装环境以后新增站点方法如下:

新增 systemd 服务(重点)

创建服务文件:

sudo nano /etc/systemd/system/mysite.service

内容(直接用 只改 3 个地方):

[Unit]
Description=MySite ASP.NET Core App
After=network.target

[Service]
WorkingDirectory=/var/www/mysite
ExecStart=/usr/bin/dotnet /var/www/mysite/MySite.dll
Restart=always
RestartSec=5
User=www-data
Environment=ASPNETCORE_URLS=http://127.0.0.1:5001
Environment=DOTNET_PRINT_TELEMETRY_MESSAGE=false

[Install]
WantedBy=multi-user.target

保存后执行:

sudo systemctl daemon-reload
sudo systemctl enable mysite
sudo systemctl start mysite

检查状态:

systemctl status mysite

新增 nginx 站点反向代理

创建 nginx 站点配置:

sudo nano /etc/nginx/sites-available/mysite

内容

server {
    listen 80;
    server_name mysite.example.com;   # 或 IP

    location / {
        proxy_pass http://127.0.0.1:5001;
        proxy_http_version 1.1;

        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection keep-alive;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

启用站点:

sudo ln -s /etc/nginx/sites-available/mysite /etc/nginx/sites-enabled/

测试 nginx 配置:

sudo nginx -t

重载 nginx:

sudo systemctl reload nginx

访问测试

浏览器访问:

http://服务器IP
或
http://mysite.example.com

常见 502 排查(非常实用)

端口是否监听

ss -tlnp | grep 5001

没有 → systemd 没跑

手动运行测试

cd /var/www/mysite
dotnet MySite.dll

是否报错?

查看日志(最重要)

journalctl -u mysite -f

删除「某个 systemd 服务」

sudo systemctl stop mysite

禁用开机自启

sudo systemctl disable mysite

删除 service 文件

sudo rm /etc/systemd/system/mysite.service

重新加载 systemd

sudo systemctl daemon-reload

(可选)确认已删除

systemctl status mysite

删除nginx的站点

先看看当前启用了哪些站点:

ls /etc/nginx/sites-enabled/

会看到已经运行的站点

default
example.com
api.example.com

这些文件通常链接到

/etc/nginx/sites-available/

删除站点(推荐做法)

方法 1:只删除启用(推荐)

如果你只是想停用站点(以后可能还用):

sudo rm /etc/nginx/sites-enabled/example.com

这只是删除软链接,不会删配置本身。

方法 2:彻底删除站点

如果你确定这个站点以后不要了:

sudo rm /etc/nginx/sites-enabled/example.com
sudo rm /etc/nginx/sites-available/example.com

注意:这一步是真正删除配置文件

测试配置是否正常(非常重要)

sudo nginx -t

重新加载 Nginx

sudo systemctl reload nginx

如果 reload 失败,可以用:

sudo systemctl restart nginx

(可选)删除站点文件目录

sudo rm -rf /var/www/example.com