安装 docker-compose

  1. 最新发行的版本地址：https://github.com/docker/compose/releases
  2. 运行以下命令以下载Docker Compose的当前稳定版本：

sudo curl -L “https://github.com/docker/compose/releases/download/v2.5.0/docker-compose-$(uname -s)-$(uname -m)” -o /usr/local/bin/docker-compose
注意: 如果无法下载,可以本地下载好后上传到服务器即可

  1. 将可执行权限应用于二进制文件：

mv docker-compose /usr/local/bin
sudo chmod +x /usr/local/bin/docker-compose
注意：如果命令docker-compose在安装后失败，请检查您的路径。您还可以创建指向/usr/bin或路径中任何其他目录的符号链接。

  1. 测试安装

docker-compose —version

bash 命令补齐

curl -L https://raw.githubusercontent.com/docker/compose/$(docker-compose version —short)/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose

安装Compose命令补全工具遇到的错误

curl -L https://raw.githubusercontent.com/docker/compose/$(docker-compose version —short)/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose
原因分析：
地址https://raw.githubusercontent.com无法访问
解决办法：
直接找到这个文件在github上的地址，然后手动复制粘贴下来
地址：https://github.com/docker/compose/blob/master/contrib/completion/bash/docker-compose
具体步骤：
地址：https://github.com/docker/compose
image.png
image.png
image.png
image.png
image.png
看文件内容开头，有两种添加方法，这里采用第一种方法：
vim /etc/bash_completion.d/docker-compose
把下面的内容给添加进去，然后关闭终端，重新打开一个终端，就生效可以使用了
文件下载地址：https://files.cnblogs.com/files/sanduzxcvbnm/docker-compose.7z
下载后直接解压缩上传到/etc/bash_completion.d/路径下即可
文件内容

  1. #!/bin/bash
  2. #
  3. # bash completion for docker-compose
  4. #
  5. # This work is based on the completion for the docker command.
  6. #
  7. # This script provides completion of:
  8. #  - commands and their options
  9. #  - service names
  10. #  - filepaths
  11. #
  12. # To enable the completions either:
  13. #  - place this file in /etc/bash_completion.d
  14. #  or
  15. #  - copy this file to e.g. ~/.docker-compose-completion.sh and add the line
  16. #    below to your .bashrc after bash completion features are loaded
  17. #    . ~/.docker-compose-completion.sh
  19. __docker_compose_previous_extglob_setting=$(shopt -p extglob)
  20. shopt -s extglob
  22. __docker_compose_q() {
  23.     docker-compose 2>/dev/null "${top_level_options[@]}" "$@"
  24. }
  26. # Transforms a multiline list of strings into a single line string
  27. # with the words separated by "|".
  28. __docker_compose_to_alternatives() {
  29.     local parts=( $1 )
  30.     local IFS='|'
  31.     echo "${parts[*]}"
  32. }
  34. # Transforms a multiline list of options into an extglob pattern
  35. # suitable for use in case statements.
  36. __docker_compose_to_extglob() {
  37.     local extglob=$( __docker_compose_to_alternatives "$1" )
  38.     echo "@($extglob)"
  39. }
  41. # Determines whether the option passed as the first argument exist on
  42. # the commandline. The option may be a pattern, e.g. `--force|-f`.
  43. __docker_compose_has_option() {
  44.     local pattern="$1"
  45.     for (( i=2; i < $cword; ++i)); do
  46.         if [[ ${words[$i]} =~ ^($pattern)$ ]] ; then
  47.             return 0
  48.         fi
  49.     done
  50.     return 1
  51. }
  53. # Returns `key` if we are currently completing the value of a map option (`key=value`)
  54. # which matches the extglob passed in as an argument.
  55. # This function is needed for key-specific completions.
  56. __docker_compose_map_key_of_current_option() {
  57.         local glob="$1"
  59.         local key glob_pos
  60.         if [ "$cur" = "=" ] ; then        # key= case
  61.                 key="$prev"
  62.                 glob_pos=$((cword - 2))
  63.         elif [[ $cur == *=* ]] ; then     # key=value case (OSX)
  64.                 key=${cur%=*}
  65.                 glob_pos=$((cword - 1))
  66.         elif [ "$prev" = "=" ] ; then
  67.                 key=${words[$cword - 2]}  # key=value case
  68.                 glob_pos=$((cword - 3))
  69.         else
  70.                 return
  71.         fi
  73.         [ "${words[$glob_pos]}" = "=" ] && ((glob_pos--))  # --option=key=value syntax
  75.         [[ ${words[$glob_pos]} == @($glob) ]] && echo "$key"
  76. }
  78. # suppress trailing whitespace
  79. __docker_compose_nospace() {
  80.     # compopt is not available in ancient bash versions
  81.     type compopt &>/dev/null && compopt -o nospace
  82. }
  85. # Outputs a list of all defined services, regardless of their running state.
  86. # Arguments for `docker-compose ps` may be passed in order to filter the service list,
  87. # e.g. `status=running`.
  88. __docker_compose_services() {
  89.     __docker_compose_q ps --services "$@"
  90. }
  92. # Applies completion of services based on the current value of `$cur`.
  93. # Arguments for `docker-compose ps` may be passed in order to filter the service list,
  94. # see `__docker_compose_services`.
  95. __docker_compose_complete_services() {
  96.     COMPREPLY=( $(compgen -W "$(__docker_compose_services "$@")" -- "$cur") )
  97. }
  99. # The services for which at least one running container exists
  100. __docker_compose_complete_running_services() {
  101.     local names=$(__docker_compose_services --filter status=running)
  102.     COMPREPLY=( $(compgen -W "$names" -- "$cur") )
  103. }
  106. _docker_compose_build() {
  107.     case "$prev" in
  108.         --build-arg)
  109.             COMPREPLY=( $( compgen -e -- "$cur" ) )
  110.             __docker_compose_nospace
  111.             return
  112.             ;;
  113.         --memory|-m)
  114.             return
  115.             ;;
  116.     esac
  118.     case "$cur" in
  119.         -*)
  120.             COMPREPLY=( $( compgen -W "--build-arg --compress --force-rm --help --memory -m --no-cache --no-rm --pull --parallel -q --quiet" -- "$cur" ) )
  121.             ;;
  122.         *)
  123.             __docker_compose_complete_services --filter source=build
  124.             ;;
  125.     esac
  126. }
  129. _docker_compose_config() {
  130.     case "$prev" in
  131.         --hash)
  132.             if [[ $cur == \\* ]] ; then
  133.                 COMPREPLY=( '\*' )
  134.             else
  135.                 COMPREPLY=( $(compgen -W "$(__docker_compose_services) \\\* " -- "$cur") )
  136.             fi
  137.             return
  138.             ;;
  139.     esac
  141.     COMPREPLY=( $( compgen -W "--hash --help --no-interpolate --profiles --quiet -q --resolve-image-digests --services --volumes" -- "$cur" ) )
  142. }
  145. _docker_compose_create() {
  146.     case "$cur" in
  147.         -*)
  148.             COMPREPLY=( $( compgen -W "--build --force-recreate --help --no-build --no-recreate" -- "$cur" ) )
  149.             ;;
  150.         *)
  151.             __docker_compose_complete_services
  152.             ;;
  153.     esac
  154. }
  157. _docker_compose_docker_compose() {
  158.     case "$prev" in
  159.         --tlscacert|--tlscert|--tlskey)
  160.             _filedir
  161.             return
  162.             ;;
  163.         --file|-f)
  164.             _filedir "y?(a)ml"
  165.             return
  166.             ;;
  167.         --ansi)
  168.             COMPREPLY=( $( compgen -W "never always auto" -- "$cur" ) )
  169.             return
  170.             ;;
  171.         --log-level)
  172.             COMPREPLY=( $( compgen -W "debug info warning error critical" -- "$cur" ) )
  173.             return
  174.             ;;
  175.         --profile)
  176.             COMPREPLY=( $( compgen -W "$(__docker_compose_q config --profiles)" -- "$cur" ) )
  177.             return
  178.             ;;
  179.         --project-directory)
  180.             _filedir -d
  181.             return
  182.             ;;
  183.         --env-file)
  184.             _filedir
  185.             return
  186.             ;;
  187.         $(__docker_compose_to_extglob "$daemon_options_with_args") )
  188.             return
  189.             ;;
  190.     esac
  192.     case "$cur" in
  193.         -*)
  194.             COMPREPLY=( $( compgen -W "$daemon_boolean_options $daemon_options_with_args $top_level_options_with_args --help -h --no-ansi --verbose --version -v" -- "$cur" ) )
  195.             ;;
  196.         *)
  197.             COMPREPLY=( $( compgen -W "${commands[*]}" -- "$cur" ) )
  198.             ;;
  199.     esac
  200. }
  203. _docker_compose_down() {
  204.     case "$prev" in
  205.         --rmi)
  206.             COMPREPLY=( $( compgen -W "all local" -- "$cur" ) )
  207.             return
  208.             ;;
  209.         --timeout|-t)
  210.             return
  211.             ;;
  212.     esac
  214.     case "$cur" in
  215.         -*)
  216.             COMPREPLY=( $( compgen -W "--help --rmi --timeout -t --volumes -v --remove-orphans" -- "$cur" ) )
  217.             ;;
  218.     esac
  219. }
  222. _docker_compose_events() {
  223.     case "$prev" in
  224.         --json)
  225.             return
  226.             ;;
  227.     esac
  229.     case "$cur" in
  230.         -*)
  231.             COMPREPLY=( $( compgen -W "--help --json" -- "$cur" ) )
  232.             ;;
  233.         *)
  234.             __docker_compose_complete_services
  235.             ;;
  236.     esac
  237. }
  240. _docker_compose_exec() {
  241.     case "$prev" in
  242.         --index|--user|-u|--workdir|-w)
  243.             return
  244.             ;;
  245.     esac
  247.     case "$cur" in
  248.         -*)
  249.             COMPREPLY=( $( compgen -W "-d --detach --help --index --privileged -T --user -u --workdir -w" -- "$cur" ) )
  250.             ;;
  251.         *)
  252.             __docker_compose_complete_running_services
  253.             ;;
  254.     esac
  255. }
  258. _docker_compose_help() {
  259.     COMPREPLY=( $( compgen -W "${commands[*]}" -- "$cur" ) )
  260. }
  262. _docker_compose_images() {
  263.     case "$cur" in
  264.         -*)
  265.             COMPREPLY=( $( compgen -W "--help --quiet -q" -- "$cur" ) )
  266.             ;;
  267.         *)
  268.             __docker_compose_complete_services
  269.             ;;
  270.     esac
  271. }
  273. _docker_compose_kill() {
  274.     case "$prev" in
  275.         -s)
  276.             COMPREPLY=( $( compgen -W "SIGHUP SIGINT SIGKILL SIGUSR1 SIGUSR2" -- "$(echo $cur | tr '[:lower:]' '[:upper:]')" ) )
  277.             return
  278.             ;;
  279.     esac
  281.     case "$cur" in
  282.         -*)
  283.             COMPREPLY=( $( compgen -W "--help -s" -- "$cur" ) )
  284.             ;;
  285.         *)
  286.             __docker_compose_complete_running_services
  287.             ;;
  288.     esac
  289. }
  292. _docker_compose_logs() {
  293.     case "$prev" in
  294.         --tail)
  295.             return
  296.             ;;
  297.     esac
  299.     case "$cur" in
  300.         -*)
  301.             COMPREPLY=( $( compgen -W "--follow -f --help --no-color --no-log-prefix --tail --timestamps -t" -- "$cur" ) )
  302.             ;;
  303.         *)
  304.             __docker_compose_complete_services
  305.             ;;
  306.     esac
  307. }
  310. _docker_compose_pause() {
  311.     case "$cur" in
  312.         -*)
  313.             COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
  314.             ;;
  315.         *)
  316.             __docker_compose_complete_running_services
  317.             ;;
  318.     esac
  319. }
  322. _docker_compose_port() {
  323.     case "$prev" in
  324.         --protocol)
  325.             COMPREPLY=( $( compgen -W "tcp udp" -- "$cur" ) )
  326.             return;
  327.             ;;
  328.         --index)
  329.             return;
  330.             ;;
  331.     esac
  333.     case "$cur" in
  334.         -*)
  335.             COMPREPLY=( $( compgen -W "--help --index --protocol" -- "$cur" ) )
  336.             ;;
  337.         *)
  338.             __docker_compose_complete_services
  339.             ;;
  340.     esac
  341. }
  344. _docker_compose_ps() {
  345.     local key=$(__docker_compose_map_key_of_current_option '--filter')
  346.     case "$key" in
  347.         source)
  348.             COMPREPLY=( $( compgen -W "build image" -- "${cur##*=}" ) )
  349.             return
  350.             ;;
  351.         status)
  352.             COMPREPLY=( $( compgen -W "paused restarting running stopped" -- "${cur##*=}" ) )
  353.             return
  354.             ;;
  355.     esac
  357.     case "$prev" in
  358.         --filter)
  359.             COMPREPLY=( $( compgen -W "source status" -S "=" -- "$cur" ) )
  360.             __docker_compose_nospace
  361.             return;
  362.             ;;
  363.     esac
  365.     case "$cur" in
  366.         -*)
  367.             COMPREPLY=( $( compgen -W "--all -a --filter --help --quiet -q --services" -- "$cur" ) )
  368.             ;;
  369.         *)
  370.             __docker_compose_complete_services
  371.             ;;
  372.     esac
  373. }
  376. _docker_compose_pull() {
  377.     case "$cur" in
  378.         -*)
  379.             COMPREPLY=( $( compgen -W "--help --ignore-pull-failures --include-deps --no-parallel --quiet -q" -- "$cur" ) )
  380.             ;;
  381.         *)
  382.             __docker_compose_complete_services --filter source=image
  383.             ;;
  384.     esac
  385. }
  388. _docker_compose_push() {
  389.     case "$cur" in
  390.         -*)
  391.             COMPREPLY=( $( compgen -W "--help --ignore-push-failures" -- "$cur" ) )
  392.             ;;
  393.         *)
  394.             __docker_compose_complete_services
  395.             ;;
  396.     esac
  397. }
  400. _docker_compose_restart() {
  401.     case "$prev" in
  402.         --timeout|-t)
  403.             return
  404.             ;;
  405.     esac
  407.     case "$cur" in
  408.         -*)
  409.             COMPREPLY=( $( compgen -W "--help --timeout -t" -- "$cur" ) )
  410.             ;;
  411.         *)
  412.             __docker_compose_complete_running_services
  413.             ;;
  414.     esac
  415. }
  418. _docker_compose_rm() {
  419.     case "$cur" in
  420.         -*)
  421.             COMPREPLY=( $( compgen -W "--force -f --help --stop -s -v" -- "$cur" ) )
  422.             ;;
  423.         *)
  424.             if __docker_compose_has_option "--stop|-s" ; then
  425.                 __docker_compose_complete_services
  426.             else
  427.                 __docker_compose_complete_services --filter status=stopped
  428.             fi
  429.             ;;
  430.     esac
  431. }
  434. _docker_compose_run() {
  435.     case "$prev" in
  436.         -e)
  437.             COMPREPLY=( $( compgen -e -- "$cur" ) )
  438.             __docker_compose_nospace
  439.             return
  440.             ;;
  441.         --entrypoint|--label|-l|--name|--user|-u|--volume|-v|--workdir|-w)
  442.             return
  443.             ;;
  444.     esac
  446.     case "$cur" in
  447.         -*)
  448.             COMPREPLY=( $( compgen -W "--detach -d --entrypoint -e --help --label -l --name --no-deps --publish -p --rm --service-ports -T --use-aliases --user -u --volume -v --workdir -w" -- "$cur" ) )
  449.             ;;
  450.         *)
  451.             __docker_compose_complete_services
  452.             ;;
  453.     esac
  454. }
  457. _docker_compose_scale() {
  458.     case "$prev" in
  459.         =)
  460.             COMPREPLY=("$cur")
  461.             return
  462.             ;;
  463.         --timeout|-t)
  464.             return
  465.             ;;
  466.     esac
  468.     case "$cur" in
  469.         -*)
  470.             COMPREPLY=( $( compgen -W "--help --timeout -t" -- "$cur" ) )
  471.             ;;
  472.         *)
  473.             COMPREPLY=( $(compgen -S "=" -W "$(__docker_compose_services)" -- "$cur") )
  474.             __docker_compose_nospace
  475.             ;;
  476.     esac
  477. }
  480. _docker_compose_start() {
  481.     case "$cur" in
  482.         -*)
  483.             COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
  484.             ;;
  485.         *)
  486.             __docker_compose_complete_services --filter status=stopped
  487.             ;;
  488.     esac
  489. }
  492. _docker_compose_stop() {
  493.     case "$prev" in
  494.         --timeout|-t)
  495.             return
  496.             ;;
  497.     esac
  499.     case "$cur" in
  500.         -*)
  501.             COMPREPLY=( $( compgen -W "--help --timeout -t" -- "$cur" ) )
  502.             ;;
  503.         *)
  504.             __docker_compose_complete_running_services
  505.             ;;
  506.     esac
  507. }
  510. _docker_compose_top() {
  511.     case "$cur" in
  512.         -*)
  513.             COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
  514.             ;;
  515.         *)
  516.             __docker_compose_complete_running_services
  517.             ;;
  518.     esac
  519. }
  522. _docker_compose_unpause() {
  523.     case "$cur" in
  524.         -*)
  525.             COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
  526.             ;;
  527.         *)
  528.             __docker_compose_complete_services --filter status=paused
  529.             ;;
  530.     esac
  531. }
  534. _docker_compose_up() {
  535.     case "$prev" in
  536.         =)
  537.             COMPREPLY=("$cur")
  538.             return
  539.             ;;
  540.         --exit-code-from)
  541.             __docker_compose_complete_services
  542.             return
  543.             ;;
  544.         --scale)
  545.             COMPREPLY=( $(compgen -S "=" -W "$(__docker_compose_services)" -- "$cur") )
  546.             __docker_compose_nospace
  547.             return
  548.             ;;
  549.         --timeout|-t)
  550.             return
  551.             ;;
  552.     esac
  554.     case "$cur" in
  555.         -*)
  556.             COMPREPLY=( $( compgen -W "--abort-on-container-exit --always-recreate-deps --attach-dependencies --build -d --detach --exit-code-from --force-recreate --help --no-build --no-color --no-deps --no-log-prefix --no-recreate --no-start --renew-anon-volumes -V --remove-orphans --scale --timeout -t" -- "$cur" ) )
  557.             ;;
  558.         *)
  559.             __docker_compose_complete_services
  560.             ;;
  561.     esac
  562. }
  565. _docker_compose_version() {
  566.     case "$cur" in
  567.         -*)
  568.             COMPREPLY=( $( compgen -W "--short" -- "$cur" ) )
  569.             ;;
  570.     esac
  571. }
  574. _docker_compose() {
  575.     local previous_extglob_setting=$(shopt -p extglob)
  576.     shopt -s extglob
  578.     local commands=(
  579.         build
  580.         config
  581.         create
  582.         down
  583.         events
  584.         exec
  585.         help
  586.         images
  587.         kill
  588.         logs
  589.         pause
  590.         port
  591.         ps
  592.         pull
  593.         push
  594.         restart
  595.         rm
  596.         run
  597.         scale
  598.         start
  599.         stop
  600.         top
  601.         unpause
  602.         up
  603.         version
  604.     )
  606.     # Options for the docker daemon that have to be passed to secondary calls to
  607.     # docker-compose executed by this script.
  608.     local daemon_boolean_options="
  609.         --skip-hostname-check
  610.         --tls
  611.         --tlsverify
  612.     "
  613.     local daemon_options_with_args="
  614.         --context -c
  615.         --env-file
  616.         --file -f
  617.         --host -H
  618.         --project-directory
  619.         --project-name -p
  620.         --tlscacert
  621.         --tlscert
  622.         --tlskey
  623.     "
  625.     # These options require special treatment when searching the command.
  626.     local top_level_options_with_args="
  627.         --ansi
  628.         --log-level
  629.         --profile
  630.     "
  632.     COMPREPLY=()
  633.     local cur prev words cword
  634.     _get_comp_words_by_ref -n : cur prev words cword
  636.     # search subcommand and invoke its handler.
  637.     # special treatment of some top-level options
  638.     local command='docker_compose'
  639.     local top_level_options=()
  640.     local counter=1
  642.     while [ $counter -lt $cword ]; do
  643.         case "${words[$counter]}" in
  644.             $(__docker_compose_to_extglob "$daemon_boolean_options") )
  645.                 local opt=${words[counter]}
  646.                 top_level_options+=($opt)
  647.                 ;;
  648.             $(__docker_compose_to_extglob "$daemon_options_with_args") )
  649.                 local opt=${words[counter]}
  650.                 local arg=${words[++counter]}
  651.                 top_level_options+=($opt $arg)
  652.                 ;;
  653.             $(__docker_compose_to_extglob "$top_level_options_with_args") )
  654.                 (( counter++ ))
  655.                 ;;
  656.             -*)
  657.                 ;;
  658.             *)
  659.                 command="${words[$counter]}"
  660.                 break
  661.                 ;;
  662.         esac
  663.         (( counter++ ))
  664.     done
  666.     local completions_func=_docker_compose_${command//-/_}
  667.     declare -F $completions_func >/dev/null && $completions_func
  669.     eval "$previous_extglob_setting"
  670.     return 0
  671. }
  673. eval "$__docker_compose_previous_extglob_setting"
  674. unset __docker_compose_previous_extglob_setting
  676. complete -F _docker_compose docker-compose docker-compose.exe

卸载docker-compose

直接移除二进制包即可
sudo rm /usr/local/bin/docker-compose