阿里云安装docker 指定版本

时间：2022-06-16 18:46:07
sh docker-install.sh 1.12.6    #ubuntu16.4 测试通过

#!/bin/sh

set -e

#

# This script is meant for quick & easy install via:

#   'curl -sSL http://acs-public-mirror.oss-cn-hangzhou.aliyuncs.com/docker-engine/internet | sh'

# or:

#   'wget -qO- http://acs-public-mirror.oss-cn-hangzhou.aliyuncs.com/docker-engine/internet | sh'

#

# For test builds (ie. release candidates):

#   'curl -fsSL http://acs-public-mirror.oss-cn-hangzhou.aliyuncs.com/docker-engine/test/internet | sh'

# or:

#   'wget -qO- http://acs-public-mirror.oss-cn-hangzhou.aliyuncs.com/docker-engine/test/internet | sh'

#

# For experimental builds:

#   'curl -fsSL http://acs-public-mirror.oss-cn-hangzhou.aliyuncs.com/docker-engine/experimental/internet | sh'

# or:

#   'wget -qO- http://acs-public-mirror.oss-cn-hangzhou.aliyuncs.com/docker-engine/experimental/internet | sh'

#

# Docker Maintainers:

#   To update this script on https://get.docker.com,

#   use hack/release.sh during a normal release,

#   or the following one-liner for script hotfixes:

#     aws s3 cp --acl public-read hack/install.sh s3://get.docker.com/index

#

url="http://acs-public-mirror.oss-cn-hangzhou.aliyuncs.com/docker-engine/internet"

apt_url="http://mirrors.aliyun.com/docker-engine/apt"

yum_url="http://mirrors.aliyun.com/docker-engine/yum"

gpg_fingerprint="58118E89F3A912897C070ADBF76221572C52609D"

key_servers="

ha.pool.sks-keyservers.net

pgp.mit.edu

keyserver.ubuntu.com

"

command_exists() {

    command -v "$@" > /dev/null >&

}

echo_docker_as_nonroot() {

    if command_exists docker && [ -e /var/run/docker.sock ]; then

        (

            set -x

            $sh_c 'docker version'

        ) || true

    fi

    your_user=your-user

    [ "$user" != 'root' ] && your_user="$user"

    # intentionally mixed spaces and tabs here -- tabs are stripped by "<<-EOF", spaces are kept in the output

    cat <<-EOF

    If you would like to use Docker as a non-root user, you should now consider

    adding your user to the "docker" group with something like:

      sudo usermod -aG docker $your_user

    Remember that you will have to log out and back in for this to take effect!

    EOF

}

# Check if this is a forked Linux distro

check_forked() {

    # Check for lsb_release command existence, it usually exists in forked distros

    if command_exists lsb_release; then

        # Check if the `-u` option is supported

        set +e

        lsb_release -a -u > /dev/null >&

        lsb_release_exit_code=$?

        set -e

        # Check if the command has exited successfully, it means we're in a forked distro

        if [ "$lsb_release_exit_code" = "" ]; then

            # Print info about current distro

            cat <<-EOF

            You're using '$lsb_dist' version '$dist_version'.

            EOF

            # Get the upstream release info

d '[[:space:]]')

f  | tr -d '[[:space:]]')

            # Print info about upstream distro

            cat <<-EOF

            Upstream release is '$lsb_dist' version '$dist_version'.

            EOF

        else

            if [ -r /etc/debian_version ] && [ "$lsb_dist" != "ubuntu" ]; then

                # We're Debian and don't even know it!

                lsb_dist=debian

                dist_version="$(cat /etc/debian_version | sed 's/\/.*//' | sed 's/\..*//')"

                case "$dist_version" in

                    |'Kali Linux 2')

                        dist_version="jessie"

                    ;;

                    )

                        dist_version="wheezy"

                    ;;

                esac

            fi

        fi

    fi

}

rpm_import_repository_key() {

    local key=$; shift

    local tmpdir=$(mktemp -d)

    chmod  "$tmpdir"

    for key_server in $key_servers ; do

        gpg --homedir "$tmpdir" --keyserver "$key_server" --recv-keys "$key" && break

    done

    gpg --homedir "$tmpdir" -k "$key" >/dev/null

    gpg --homedir "$tmpdir" --export --armor "$key" > "$tmpdir"/repo.key

    rpm --import "$tmpdir"/repo.key

    rm -rf "$tmpdir"

}

semverParse() {

    major="${1%%.*}"

    minor="${1#$major.}"

    minor="${minor%%.*}"

    patch="${1#$major.$minor.}"

    patch="${patch%%[-.]*}"

}

do_install() {

    case "$(uname -m)" in

        *)

            ;;

        *)

            cat >& <<-'EOF'

            Error: you are not using a 64bit platform.

            Docker currently only supports 64bit platforms.

            EOF

            exit

            ;;

    esac

    if command_exists docker; then

        version="$(docker -v | awk -F '[ ,]+' '{ print $3 }')"

        MAJOR_W=

        MINOR_W=

        semverParse $version

        shouldWarn=

        if [ $major -lt $MAJOR_W ]; then

            shouldWarn=

        fi

        if [ $major -le $MAJOR_W ] && [ $minor -lt $MINOR_W ]; then

            shouldWarn=

        fi

        cat >& <<-'EOF'

            Warning: the "docker" command appears to already exist on this system.

            If you already have Docker installed, this script can cause trouble, which is

            why we're displaying this warning and provide the opportunity to cancel the

            installation.

            If you installed the current Docker package using this script and are using it

        EOF

        if [ $shouldWarn -eq  ]; then

            cat >& <<-'EOF'

            again to update Docker, we urge you to migrate your image store before upgrading

            to v1.+.

            You can find instructions for this here:

            https://github.com/docker/docker/wiki/Engine-v1.10.0-content-addressability-migration

            EOF

        else

            cat >& <<-'EOF'

            again to update Docker, you can safely ignore this message.

            EOF

        fi

        cat >& <<-'EOF'

            You may press Ctrl+C now to abort this script.

        EOF

        ( set -x; sleep  )

    fi

    user="$(id -un 2>/dev/null || true)"

    sh_c='sh -c'

    if [ "$user" != 'root' ]; then

        if command_exists sudo; then

            sh_c='sudo -E sh -c'

        elif command_exists su; then

            sh_c='su -c'

        else

            cat >& <<-'EOF'

            Error: this installer needs the ability to run commands as root.

            We are unable to find either "sudo" or "su" available to make this happen.

            EOF

            exit

        fi

    fi

    curl=''

    if command_exists curl; then

        curl='curl -sSL'

    elif command_exists wget; then

        curl='wget -qO-'

    elif command_exists busybox && busybox --list-modules | grep -q wget; then

        curl='busybox wget -qO-'

    fi

    # check to see which repo they are trying to install from

    if [ -z "$repo" ]; then

        repo='main'

        if [ "http://acs-public-mirror.oss-cn-hangzhou.aliyuncs.com/docker-engine/test/internet" = "$url" ]; then

            repo='testing'

 then

            repo='experimental'

        fi

    fi

    # perform some very rudimentary platform detection

    lsb_dist=''

    dist_version=''

    if command_exists lsb_release; then

        lsb_dist="$(lsb_release -si)"

    fi

    if [ -z "$lsb_dist" ] && [ -r /etc/lsb-release ]; then

        lsb_dist="$(. /etc/lsb-release && echo "$DISTRIB_ID")"

    fi

    if [ -z "$lsb_dist" ] && [ -r /etc/debian_version ]; then

        lsb_dist='debian'

    fi

    if [ -z "$lsb_dist" ] && [ -r /etc/fedora-release ]; then

        lsb_dist='fedora'

    fi

    if [ -z "$lsb_dist" ] && [ -r /etc/oracle-release ]; then

        lsb_dist='oracleserver'

    fi

    if [ -z "$lsb_dist" ]; then

        if [ -r /etc/centos-release ] || [ -r /etc/redhat-release ]; then

            lsb_dist='centos'

        fi

    fi

    if [ -z "$lsb_dist" ] && [ -r /etc/os-release ]; then

        lsb_dist="$(. /etc/os-release && echo "$ID")"

    fi

    lsb_dist="$(echo "$lsb_dist" | tr '[:upper:]' '[:lower:]')"

    case "$lsb_dist" in

        ubuntu)

            if command_exists lsb_release; then

                dist_version="$(lsb_release --codename | cut -f2)"

            fi

            if [ -z "$dist_version" ] && [ -r /etc/lsb-release ]; then

                dist_version="$(. /etc/lsb-release && echo "$DISTRIB_CODENAME")"

            fi

        ;;

        debian)

            dist_version="$(cat /etc/debian_version | sed 's/\/.*//' | sed 's/\..*//')"

            case "$dist_version" in

                )

                    dist_version="jessie"

                ;;

                )

                    dist_version="wheezy"

                ;;

            esac

        ;;

        oracleserver)

            # need to switch lsb_dist to match yum repo URL

            lsb_dist="oraclelinux"

ed 's/\..*//' | sed 's/Server*//' | sort -r | head -)"

        ;;

        fedora|centos)

ed 's/\..*//' | sed 's/Server*//' | sort -r | head -)"

        ;;

        *)

            if command_exists lsb_release; then

                dist_version="$(lsb_release --codename | cut -f2)"

            fi

            if [ -z "$dist_version" ] && [ -r /etc/os-release ]; then

                dist_version="$(. /etc/os-release && echo "$VERSION_ID")"

            fi

        ;;

    esac

    # Check if this is a forked Linux distro

    check_forked

    # Run setup for each distro accordingly

    case "$lsb_dist" in

        amzn)

            (

            set -x

            $sh_c 'sleep 3; yum -y -q install docker'

            )

            echo_docker_as_nonroot

            exit

            ;;

        'opensuse project'|opensuse)

            echo 'Going to perform the following operations:'

            if [ "$repo" != 'main' ]; then

                echo '  * add repository obs://Virtualization:containers'

            fi

            echo '  * install Docker'

            $sh_c 'echo "Press CTRL-C to abort"; sleep 3'

            if [ "$repo" != 'main' ]; then

                # install experimental packages from OBS://Virtualization:containers

                (

                    set -x

                    zypper -n ar -f obs://Virtualization:containers Virtualization:containers

                    rpm_import_repository_key 55A0B34D49501BB7CA474F5AA193FBB572174FC2

                )

            fi

            (

                set -x

                zypper -n install docker

            )

            echo_docker_as_nonroot

            exit

            ;;

        'suse linux'|sle[sd])

            echo 'Going to perform the following operations:'

            if [ "$repo" != 'main' ]; then

                echo '  * add repository obs://Virtualization:containers'

                echo '  * install experimental Docker using packages NOT supported by SUSE'

            else

                echo '  * add the "Containers" module'

                echo '  * install Docker using packages supported by SUSE'

            fi

            $sh_c 'echo "Press CTRL-C to abort"; sleep 3'

            if [ "$repo" != 'main' ]; then

                # install experimental packages from OBS://Virtualization:containers

 by SUSE'

                (

                    set -x

                    zypper -n ar -f obs://Virtualization:containers/SLE_12 Virtualization:containers

                    rpm_import_repository_key 55A0B34D49501BB7CA474F5AA193FBB572174FC2

                )

            else

                # Add the containers module

                # Note well-: the SLE machine must already be registered against SUSE Customer Center

                # Note well-: the `-r ""` is required to workaround a known issue of SUSEConnect

                (

                    set -x

                    SUSEConnect -p sle-module-containers//x86_64 -r ""

                )

            fi

            (

                set -x

                zypper -n install docker

            )

            echo_docker_as_nonroot

            exit

            ;;

        ubuntu|debian)

            export DEBIAN_FRONTEND=noninteractive

            did_apt_get_update=

            apt_get_update() {

                if [ -z "$did_apt_get_update" ]; then

                    ( set -x; $sh_c 'sleep 3; apt-get update || true' )

                    did_apt_get_update=

                fi

            }

            # aufs is preferred over devicemapper; try to ensure the driver is available.

            if ! grep -q aufs /proc/filesystems && ! $sh_c 'modprobe aufs'; then

/dev/null; then

                    kern_extras="linux-image-extra-$(uname -r) linux-image-extra-virtual"

                    apt_get_update

                    ( set -x; $sh_c 'sleep 3; apt-get install -y -q '"$kern_extras" ) || true

                    if ! grep -q aufs /proc/filesystems && ! $sh_c 'modprobe aufs'; then

                        echo >& 'Warning: tried to install '"$kern_extras"' (for AUFS)'

!'

                        ( set -x; sleep  )

                    fi

                else

                    echo >& 'Warning: current kernel is not supported by the linux-image-extra-virtual'

                    echo >& ' package.  We have no AUFS support.  Consider installing the packages'

                    echo >& ' linux-image-virtual kernel and linux-image-extra-virtual for AUFS support.'

                    ( set -x; sleep  )

                fi

            fi

            # install apparmor utils if they're missing and apparmor is enabled in the kernel

            # otherwise Docker will fail to start

            if [ "$(cat /sys/module/apparmor/parameters/enabled 2>/dev/null)" = 'Y' ]; then

                if command -v apparmor_parser >/dev/null >&; then

                    echo 'apparmor is enabled in the kernel and apparmor utils were already installed'

                else

                    echo 'apparmor is enabled in the kernel, but apparmor_parser missing'

                    apt_get_update

                    ( set -x; $sh_c 'sleep 3; apt-get install -y -q apparmor' )

                fi

            fi

            if [ ! -e /usr/lib/apt/methods/https ]; then

                apt_get_update

                ( set -x; $sh_c 'sleep 3; apt-get install -y -q apt-transport-https ca-certificates' )

            fi

            if [ -z "$curl" ]; then

                apt_get_update

                ( set -x; $sh_c 'sleep 3; apt-get install -y -q curl ca-certificates' )

                curl='curl -sSL'

            fi

            (

            set -x

            for key_server in $key_servers ; do

                $sh_c "apt-key adv --keyserver hkp://${key_server}:80 --recv-keys ${gpg_fingerprint}" && break

            done

            $sh_c "apt-key adv -k ${gpg_fingerprint} >/dev/null"

            $sh_c "mkdir -p /etc/apt/sources.list.d"

} > /etc/apt/sources.list.d/docker.list"

ker-engine; else apt-get install -y -q docker-engine=${docker_version}-~ubuntu-${dist_version}; fi"

            )

            echo_docker_as_nonroot

            exit

            ;;

        fedora|centos|oraclelinux)

            $sh_c "cat >/etc/yum.repos.d/docker-${repo}.repo" <<-EOF

            [docker-${repo}-repo]

            name=Docker ${repo} Repository

            baseurl=${yum_url}/repo/${repo}/${lsb_dist}/${dist_version}

            enabled=

            gpgcheck=

            gpgkey=${yum_url}/gpg

            EOF

            if [ "$lsb_dist" = "fedora" ] && [ "$dist_version" -ge "" ]; then

                (

                    set -x

                    $sh_c 'sleep 3; dnf -y -q install docker-engine'

                )

            else

                (

                    set -x

ll docker-engine; else yum -y -q install docker-engine-$docker_version; fi"

                )

            fi

            echo_docker_as_nonroot

            exit

            ;;

        gentoo)

hen

 in the output

                cat >& <<-'EOF'

                  You appear to be trying to install the latest nightly build in Gentoo.'

                  The portage tree should contain the latest stable release of Docker, but'

                  if you want something more recent, you can always use the live ebuild'

                  provided in the "docker" overlay available via layman.  For more'

                  instructions, please see the following URL:'

                    https://github.com/tianon/docker-overlay#using-this-overlay'

                  After adding the "docker" overlay, you should be able to:'

                    emerge -av =app-emulation/docker-'

                EOF

                exit

            fi

            (

                set -x

                $sh_c 'sleep 3; emerge app-emulation/docker'

            )

            exit

            ;;

    esac

    # intentionally mixed spaces and tabs here -- tabs are stripped by "<<-'EOF'", spaces are kept in the output

    cat >& <<-'EOF'

      Either your platform is not easily detectable, is not supported by this

      installer script (yet - PRs welcome! [hack/install.sh]), or does not yet have

      a package for Docker.  Please visit the following URL for more detailed

      installation instructions:

        https://docs.docker.com/engine/installation/

    EOF

    exit

}

# wrapped up in a function so that we have some protection against only getting

# half the file during "curl | sh"

if [ ! -z $ ] ; then docker_version=$; fi

do_install

代码

加速器

#!/bin/sh

sudo mkdir -p /etc/docker

sudo tee /etc/docker/daemon.json <<-'EOF'

{

  "registry-mirrors": ["https://xxx.mirror.aliyuncs.com"]

}

EOF

sudo systemctl daemon-reload

sudo systemctl restart docker

　　

相关文章