Detaillierte Erklärung zur sauberen Deinstallation von Docker

yum entferne Docker \
         Docker-Client \
         docker-client-neueste \
         docker-allgemein \
         docker-neueste \
         docker-latest-logrotate \
         docker-logrotate \
         docker-selinux \
         Docker-Engine-Selinux \
         Docker-Engine

rm -rf /etc/systemd/system/docker.service.d

rm -rf /var/lib/docker

rm -rf /var/run/docker

#!/bin/sh
setze -e

# Dieses Skript ist für eine schnelle und einfache Installation gedacht über:
# $ curl -fsSL get.docker.com -o get-docker.sh
# $ sh get-docker.sh
#
# Für Testbuilds (d. h. Release-Kandidaten):
# $ curl -fsSL test.docker.com -o test-docker.sh
# $ sh test-docker.sh
#
# HINWEIS: Stellen Sie sicher, dass Sie den Inhalt des Skripts überprüfen
# Ihr Download stimmt mit dem Inhalt von install.sh überein
# befindet sich unter https://github.com/docker/docker-install
# vor der Ausführung.
#
# Git-Commit von https://github.com/docker/docker-install, wenn
# das Skript wurde hochgeladen (darf nur durch einen Upload-Job geändert werden):
SCRIPT_COMMIT_SHA=36b78b2


# Dieser Wert wird automatisch geändert für:
# * Rand
# * prüfen
# * experimentell
DEFAULT_CHANNEL_VALUE="Kante"
wenn [ -z "$CHANNEL" ]; dann
  KANAL=$DEFAULT_CHANNEL_VALUE
fi

DEFAULT_DOWNLOAD_URL="https://download.docker.com"
wenn [ -z "$DOWNLOAD_URL" ]; dann
  DOWNLOAD_URL=$DEFAULT_DOWNLOAD_URL
fi

DEFAULT_REPO_FILE="docker-ce.repo"
wenn [ -z "$REPO_FILE" ]; dann
  REPO_FILE="$DEFAULT_REPO_FILE"
fi

SUPPORT_MAP="
x86_64-centos-7
x86_64-fedora-26
x86_64-fedora-27
x86_64-fedora-28
x86_64-debian-wheezy
x86_64-debian-jessie
x86_64-debian-stretch
x86_64-debian-buster
x86_64-ubuntu-vertrauenswürdig
x86_64-ubuntu-xenial
x86_64-ubuntu-bionic
x86_64-ubuntu-kunstvoll
s390x-ubuntu-xenial
s390x-ubuntu-bionic
s390x-ubuntu-kunstvoll
ppc64le-ubuntu-xenial
ppc64le-ubuntu-bionic
ppc64le-ubuntu-kunstvoll
aarch64-ubuntu-xenial
aarch64-ubuntu-bionic
aarch64-debian-jessie
aarch64-debian-stretch
aarch64-debian-buster
aarch64-fedora-26
aarch64-fedora-27
aarch64-fedora-28
aarch64-centos-7
armv6l-raspbian-jessie
armv7l-raspbian-jessie
armv6l-raspbian-strecken
armv7l-raspbian-strecken
armv7l-debian-jessie
armv7l-debian-stretch
armv7l-debian-buster
armv7l-ubuntu-vertrauenswürdig
armv7l-ubuntu-xenial
armv7l-ubuntu-bionic
armv7l-ubuntu-kunstvoll
"

Spiegel = ''
DRY_RUN=${DRY_RUN:-}
während [ $# -gt 0 ]; machen
  Fall "$1" in
    --Spiegel)
      Spiegel="$2"
      Schicht
      ;;
    --Trockenlauf)
      DRY_RUN = 1
      ;;
    --*)
      echo "Unzulässige Option $1"
      ;;
  esac
  Verschiebung $(( $# > 0 ? 1 : 0 ))
Erledigt

Fall "$mirror" in
  Aliyun
    DOWNLOAD_URL="https://mirrors.aliyun.com/docker-ce"
    ;;
  AzureChinaCloud)
    DOWNLOAD_URL="https://mirror.azure.cn/docker-ce"
    ;;
esac

Befehl_existiert() {
  Befehl -v "$@" > /dev/null 2>&1
}

ist_trockenlauf() {
  wenn [ -z "$DRY_RUN" ]; dann
    Rückgabe 1
  anders
    Rückgabe 0
  fi
}

Veraltungshinweis() {
  Verteilung=$1
  Datum=$2
  Echo
  echo "WARNUNG ZUR VERALTUNG:"
  echo "Die Distribution $distro wird ab $date in diesem Skript nicht mehr unterstützt."
  echo " Wenn Sie der Meinung sind, dass es sich hierbei um einen Fehler handelt, melden Sie das Problem bitte unter https://github.com/docker/docker-install/issues/new"
  Echo
  Schlaf 10
}

get_distribution() {
  lsb_dist=""
  # Jedes System, das wir offiziell unterstützen, hat /etc/os-release
  wenn [ -r /etc/os-release ]; dann
    lsb_dist="$(./etc/os-release && echo "$ID")"
  fi
  # Die Rückgabe eines leeren Strings sollte hier in Ordnung sein, da die
  # Case-Anweisungen werden nur ausgeführt, wenn Sie einen tatsächlichen Wert angeben
  echo "$lsb_dist"
}

add_debian_backport_repo() {
  debian_version="$1"
  backports="deb http://ftp.debian.org/debian $debian_version-backports main"
  wenn !grep -Fxq "$backports" /etc/apt/sources.list; dann
    (set -x; $sh_c "echo \"$backports\" >> /etc/apt/sources.list")
  fi
}

echo_docker_as_nonroot() {
  wenn is_dry_run; dann
    zurückkehren
  fi
  wenn command_exists docker && [ -e /var/run/docker.sock ]; dann
    (
      setze -x
      $ sh_c 'Docker-Version'
    ) || wahr
  fi
  your_user=Ihr Benutzer
  [ "$user" != 'root' ] && Ihr_Benutzer="$user"
  # hier absichtlich Leerzeichen und Tabulatoren vermischt -- Tabulatoren werden durch "<<-EOF" entfernt, Leerzeichen bleiben in der Ausgabe erhalten
  echo "Wenn Sie Docker als Nicht-Root-Benutzer verwenden möchten, sollten Sie jetzt Folgendes berücksichtigen"
  echo "Fügen Sie Ihren Benutzer der Gruppe \"Docker\" mit etwas wie: hinzu"
  Echo
  echo " sudo usermod -aG docker $Ihr_Benutzer"
  Echo
  echo "Denken Sie daran, dass Sie sich ab- und wieder anmelden müssen, damit die Änderungen wirksam werden!"
  Echo
  echo "WARNUNG: Das Hinzufügen eines Benutzers zur Gruppe \"Docker\" ermöglicht die Ausführung"
  echo " Container, die verwendet werden können, um Root-Rechte auf dem zu erhalten"
  echo " Docker-Host."
  echo "Siehe https://docs.docker.com/engine/security/security/#docker-daemon-attack-surface"
  echo " für weitere Informationen."

}

# Überprüfen Sie, ob dies eine gegabelte Linux-Distribution ist
check_forked() {

  # Überprüfen Sie, ob der Befehl lsb_release vorhanden ist. In gegabelten Distributionen ist er normalerweise vorhanden.
  wenn command_exists lsb_release; dann
    # Prüfen Sie, ob die Option „-u“ unterstützt wird
    Satz +e
    lsb_release -a -u > /dev/null 2>&1
    lsb_release_exit_code=$?
    setze -e

    # Überprüfen Sie, ob der Befehl erfolgreich beendet wurde. Dies bedeutet, dass wir uns in einer gegabelten Distribution befinden.
    wenn [ "$lsb_release_exit_code" = "0" ]; dann
      # Informationen zur aktuellen Distribution drucken
      Katze <<-EOF
      Sie verwenden „$lsb_dist“, Version „$dist_version“.
      Ende der Laufzeit

      # Holen Sie sich die Upstream-Release-Informationen
      lsb_dist=$(lsb_release -a -u 2>&1 | tr '[:upper:]' '[:lower:]' | grep -E 'id' | cut -d ':' -f 2 | tr -d '[:space:]')
      dist_version=$(lsb_release -a -u 2>&1 | tr '[:upper:]' '[:lower:]' | grep -E 'Codename' | cut -d ':' -f 2 | tr -d '[:space:]')

      # Informationen zur Upstream-Distribution drucken
      Katze <<-EOF
      Die Upstream-Version ist „$lsb_dist“, Version „$dist_version“.
      Ende der Laufzeit
    anders
      wenn [ -r /etc/debian_version ] && [ "$lsb_dist" != "ubuntu" ] && [ "$lsb_dist" != "raspbian" ]; dann
        wenn [ "$lsb_dist" = "osmc" ]; dann
          # OSMC läuft mit Raspbian
          lsb_dist=raspbian
        anders
          # Wir sind Debian und wissen es nicht einmal!
          lsb_dist=debian
        fi
        dist_version="$(sed 's/\/.*//' /etc/debian_version | sed 's/\..*//')"
        Fall "$dist_version" in
          9)
            dist_version="strecken"
          ;;
          8|'Kali Linux 2')
            dist_version="jessie"
          ;;
          7)
            dist_version="wheezy"
          ;;
        esac
      fi
    fi
  fi
}

semverParse() {
  Hauptsächlich="${1%%.*}"
  Nebenfach="${1#$Hauptfach.}"
  geringfügig="${minderjährig%%.*}"
  Patch="${1#$major.$minor.}"
  Patch="${patch%%[-.]*}"
}

ee_notice() {
  Echo
  Echo
  echo "WARNUNG: $1 wird jetzt nur noch von Docker EE unterstützt"
  echo " Weitere Informationen zu Docker EE finden Sie unter https://store.docker.com"
  Echo
  Echo
}

installieren() {
  echo "# Docker-Installationsskript ausführen, Commit: $SCRIPT_COMMIT_SHA"

  wenn command_exists Docker; dann
    docker_version="$(docker -v | cut -d ' ' -f3 | cut -d ',' -f1)"
    MAJOR_W = 1
    MINOR_W=10

    semverParse "$docker_version"

    sollteWarnen=0
    wenn [ "$major" -lt "$MAJOR_W" ]; dann
      sollteWarnen=1
    fi

    wenn [ "$major" -le "$MAJOR_W" ] && [ "$minor" -lt "$MINOR_W" ]; dann
      sollteWarnen=1
    fi

    Katze >&2 <<-'EOF'
      Warnung: Der Befehl „Docker“ scheint auf diesem System bereits vorhanden zu sein.

      Wenn Sie Docker bereits installiert haben, kann dieses Skript Probleme verursachen.
      warum wir diese Warnung anzeigen und die Möglichkeit bieten, den Vorgang abzubrechen
      Installation.

      Wenn Sie das aktuelle Docker-Paket mit diesem Skript installiert haben und es verwenden
    Ende der Laufzeit

    wenn [ $shouldWarn -eq 1 ]; dann
      Katze >&2 <<-'EOF'
      Um Docker erneut zu aktualisieren, empfehlen wir Ihnen, Ihren Image-Store vor dem Upgrade zu migrieren.
      auf v1.10+.

      Eine Anleitung hierzu finden Sie hier:
      https://github.com/docker/docker/wiki/Engine-v1.10.0-content-addressability-migration
      Ende der Laufzeit
    anders
      Katze >&2 <<-'EOF'
      Sobald Sie Docker erneut aktualisieren, können Sie diese Meldung getrost ignorieren.
      Ende der Laufzeit
    fi

    Katze >&2 <<-'EOF'

      Sie können jetzt Strg+C drücken, um dieses Skript abzubrechen.
    Ende der Laufzeit
    ( setze -x; schlaf 20 )
  fi

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

  sh_c='sh -c'
  wenn [ "$user" != 'root' ]; dann
    wenn command_exists sudo; dann
      sh_c='sudo -E sh -c'
    elif command_exists su; dann
      sh_c='su -c'
    anders
      Katze >&2 <<-'EOF'
      Fehler: Dieses Installationsprogramm muss die Möglichkeit haben, Befehle als Root auszuführen.
      Wir können weder „sudo“ noch „su“ finden, um dies zu ermöglichen.
      Ende der Laufzeit
      Ausfahrt 1
    fi
  fi

  wenn is_dry_run; dann
    sh_c="echo"
  fi

  # führen Sie eine sehr rudimentäre Plattformerkennung durch
  lsb_dist = $( get_distribution )
  lsb_dist="$(echo "$lsb_dist" | tr '[:upper:]' '[:lower:]')"

  Fall "$lsb_dist" in

    Ubuntu)
      wenn command_exists lsb_release; dann
        dist_version="$(lsb_release --codename | cut -f2)"
      fi
      wenn [ -z "$dist_version" ] && [ -r /etc/lsb-release ]; dann
        dist_version="$(./etc/lsb-release && echo "$DISTRIB_CODENAME")"
      fi
    ;;

    debian|raspbian)
      dist_version="$(sed 's/\/.*//' /etc/debian_version | sed 's/\..*//')"
      Fall "$dist_version" in
        9)
          dist_version="strecken"
        ;;
        8)
          dist_version="jessie"
        ;;
        7)
          dist_version="wheezy"
        ;;
      esac
    ;;

    Centos)
      wenn [ -z "$dist_version" ] && [ -r /etc/os-release ]; dann
        dist_version="$(./etc/os-release && echo "$VERSION_ID")"
      fi
    ;;

    rhel|ol|sles)
      ee_notice "$lsb_dist"
      Ausfahrt 1
      ;;

    *)
      wenn command_exists lsb_release; dann
        dist_version="$(lsb_release --release | cut -f2)"
      fi
      wenn [ -z "$dist_version" ] && [ -r /etc/os-release ]; dann
        dist_version="$(./etc/os-release && echo "$VERSION_ID")"
      fi
    ;;

  esac

  # Überprüfen Sie, ob dies eine gegabelte Linux-Distribution ist
  check_forked

  # Prüfen Sie, ob wir diese Konfiguration tatsächlich unterstützen
  wenn ! echo "$SUPPORT_MAP" | grep "$(uname -m)-$lsb_dist-$dist_version" >/dev/null; dann
    Katze >&2 <<-'EOF'

    Entweder ist Ihre Plattform nicht leicht zu erkennen oder wird von diesem nicht unterstützt
    Installationsskript.
    Ausführlichere Installationsanweisungen finden Sie unter der folgenden URL:

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

    Ende der Laufzeit
    Ausfahrt 1
  fi

  # Führen Sie das Setup für jede Distribution entsprechend aus
  Fall "$lsb_dist" in
    Ubuntu|Debian|Raspbian)
      pre_reqs="apt-transport-https ca-certificates curl"
      wenn [ "$lsb_dist" = "debian" ]; dann
        wenn [ "$dist_version" = "wheezy" ]; dann
          add_debian_backport_repo "$dist_version"
        fi
        # libseccomp2 existiert nicht für die Debian-Jessie-Haupt-Repos für aarch64
        wenn [ "$(uname -m)" = "aarch64" ] && [ "$dist_version" = "jessie" ]; dann
          add_debian_backport_repo "$dist_version"
        fi
      fi

      # TODO: 31. August 2018 hier löschen,
      wenn [ "$lsb_dist" = "ubuntu" ] && [ "$dist_version" = "artful" ]; dann
        deprecation_notice "$lsb_dist $dist_version" "31. August 2018"
      fi
      # TODO: 31. August 2018 bis hierhin löschen,

      wenn ! Befehl -v gpg > /dev/null; dann
        pre_reqs="$pre_reqs gnupg"
      fi
      apt_repo="deb [arch=$(dpkg --print-architecture)] $DOWNLOAD_URL/linux/$lsb_dist $dist_version $CHANNEL"
      (
        wenn ! ist_Trockenlauf; dann
          setze -x
        fi
        $sh_c 'apt-get update -qq >/dev/null'
        $sh_c "apt-get install -y -qq $pre_reqs >/dev/null"
        $sh_c "curl -fsSL \"$DOWNLOAD_URL/linux/$lsb_dist/gpg\" | apt-key add -qq - >/dev/null"
        $sh_c "echo \"$apt_repo\" > /etc/apt/sources.list.d/docker.list"
        wenn [ "$lsb_dist" = "debian" ] && [ "$dist_version" = "wheezy" ]; dann
          $sh_c 'sed -i "/deb-src.*download\.docker/d" /etc/apt/sources.list.d/docker.list'
        fi
        $sh_c 'apt-get update -qq >/dev/null'
      )
      pkg_version=""
      wenn [ ! -z "$VERSION" ]; dann
        wenn is_dry_run; dann
          echo "# WARNUNG: VERSION-Pinning wird in DRY_RUN nicht unterstützt"
        anders
          # Funktioniert mit unvollständigen IE-Versionen (17.12), holt sich aber möglicherweise nicht die „neueste“ Version, wenn man sich im Testkanal befindet
          pkg_pattern="$(echo "$VERSION" | sed "s/-ce-/~ce~.*/g" | sed "s/-/.*/g").*-0~$lsb_dist"
          Suchbefehl="apt-cache madison 'docker-ce' | grep '$pkg_pattern' | head -1 | cut -d' ' -f 4"
          pkg_version="$($sh_c "$Suchbefehl")"
          echo "INFO: Suche im Repository nach VERSION '$VERSION'"
          echo "INFO: $Suchbefehl"
          wenn [ -z "$pkg_version" ]; dann
            Echo
            echo "FEHLER: '$VERSION' nicht in den Ergebnissen von apt-cache madison gefunden"
            Echo
            Ausfahrt 1
          fi
          pkg_version="=$pkg_version"
        fi
      fi
      (
        wenn ! ist_Trockenlauf; dann
          setze -x
        fi
        $sh_c "apt-get install -y -qq --no-install-recommends docker-ce$pkg_version >/dev/null"
      )
      echo_docker_as_nonroot
      Ausfahrt 0
      ;;
    (CentOS | Fedora)
      yum_repo="$DOWNLOAD_URL/linux/$lsb_dist/$REPO_FILE"
      wenn ! curl -Ifs "$yum_repo" > /dev/null; dann
        echo "Fehler: Repository-Datei $yum_repo kann nicht gecurlt werden, ist sie gültig?"
        Ausfahrt 1
      fi
      wenn [ "$lsb_dist" = "fedora" ]; dann
        wenn [ "$dist_version" -lt "26" ]; dann
          echo "Fehler: Nur Fedora >=26 werden unterstützt"
          Ausfahrt 1
        fi

        pkg_manager="nicht gefunden"
        config_manager="dnf Konfigurationsmanager"
        enable_channel_flag="--set-enabled"
        Vorbedingungen = "dnf-plugins-core"
        pkg_suffix="fc$dist_version"
      anders
        pkg_manager="lecker"
        config_manager="yum-config-manager"
        enable_channel_flag="--aktivieren"
        pre_reqs="yum-utils"
        pkg_suffix="el"
      fi
      (
        wenn ! ist_Trockenlauf; dann
          setze -x
        fi
        $sh_c "$pkg_manager installieren -y -q $pre_reqs"
        $sh_c "$config_manager --add-repo $yum_repo"

        wenn [ "$CHANNEL" != "stabil" ]; dann
          $sh_c "$config_manager $enable_channel_flag docker-ce-$CHANNEL"
        fi
        $sh_c "$pkg_manager Makecache"
      )
      pkg_version=""
      wenn [ ! -z "$VERSION" ]; dann
        wenn is_dry_run; dann
          echo "# WARNUNG: VERSION-Pinning wird in DRY_RUN nicht unterstützt"
        anders
          pkg_pattern="$(echo "$VERSION" | sed "s/-ce-/\\\\.ce.*/g" | sed "s/-/.*/g").*$pkg_suffix"
          Suchbefehl="$pkg_manager-Liste --showduplicates 'docker-ce' | grep '$pkg_pattern' | tail -1 | awk '{print \$2}'"
          pkg_version="$($sh_c "$Suchbefehl")"
          echo "INFO: Suche im Repository nach VERSION '$VERSION'"
          echo "INFO: $Suchbefehl"
          wenn [ -z "$pkg_version" ]; dann
            Echo
            echo "FEHLER: '$VERSION' nicht in den Ergebnissen der $pkg_manager-Liste gefunden"
            Echo
            Ausfahrt 1
          fi
          # Schneiden Sie die Epoche aus und stellen Sie sie mit einem '-' voran.
          pkg_version="-$(echo "$pkg_version" | cut -d':' -f 2)"
        fi
      fi
      (
        wenn ! ist_Trockenlauf; dann
          setze -x
        fi
        $sh_c "$pkg_manager install -y -q docker-ce$pkg_version"
      )
      echo_docker_as_nonroot
      Ausfahrt 0
      ;;
  esac
  Ausfahrt 1
}

# in eine Funktion verpackt, damit wir einen gewissen Schutz davor haben, nur
# die Hälfte der Datei während "curl | sh"
installieren

chmod +x getdocker.sh 
./getdocker.sh -s docker --mirror Aliyun