diff --git a/doc/administration/backup_restore/restore_gitlab.md b/doc/administration/backup_restore/restore_gitlab.md
index 01cb1bf88d3178755035d1ba511f2194e17ac59d..709f34d951a63bf866aca0aba518036c400b22aa 100644
--- a/doc/administration/backup_restore/restore_gitlab.md
+++ b/doc/administration/backup_restore/restore_gitlab.md
@@ -187,7 +187,7 @@ The GitLab Helm chart uses the process documented in
 
 ### Restore for Docker image installations
 
-If you're using [Docker Swarm](../../install/docker/installation.md#install-gitlab-using-docker-swarm-mode),
+If you're using [Docker Swarm](../../install/docker/installation.md#install-gitlab-by-using-docker-swarm-mode),
 the container might restart during the restore process because Puma is shut down,
 and so the container health check fails. To work around this problem,
 temporarily disable the health check mechanism.
diff --git a/doc/administration/docs_self_host.md b/doc/administration/docs_self_host.md
index 0a4f55a04864e21d3314f57b1db9458310d7c946..70dc6367cc3e7891c6f31dfc54bdff5336a0d90d 100644
--- a/doc/administration/docs_self_host.md
+++ b/doc/administration/docs_self_host.md
@@ -52,7 +52,7 @@ To run the GitLab product documentation website in a Docker container:
      ```
 
    - If you host your GitLab instance using
-     [Docker compose](../install/docker/installation.md#install-gitlab-using-docker-compose),
+     [Docker compose](../install/docker/installation.md#install-gitlab-by-using-docker-compose),
      add the following to your existing `docker-compose.yaml`:
 
      ```yaml
diff --git a/doc/install/docker/backup_restore.md b/doc/install/docker/backup_restore.md
index aefe071cf5bc532fcb0133b59e9c83112fe4feb6..0560dc22b97fa7d7fdd222031a006bdc370696ea 100644
--- a/doc/install/docker/backup_restore.md
+++ b/doc/install/docker/backup_restore.md
@@ -28,7 +28,7 @@ WARNING:
 [Backing up the GitLab secrets file](../../administration/backup_restore/backup_gitlab.md#storing-configuration-files) is required
 to avoid [complicated steps](../../administration/backup_restore/troubleshooting_backup_gitlab.md#when-the-secrets-file-is-lost) when recovering
 GitLab from backup. The secrets file is stored at `/etc/gitlab/gitlab-secrets.json` inside the container, or
-`$GITLAB_HOME/config/gitlab-secrets.json` [on the container host](installation.md#set-up-the-volumes-location).
+`$GITLAB_HOME/config/gitlab-secrets.json` [on the container host](installation.md#create-a-directory-for-the-volumes).
 
 ## Create a database backup
 
@@ -39,6 +39,6 @@ docker exec -t <container name> gitlab-backup create SKIP=artifacts,repositories
 ```
 
 The backup is written to `/var/opt/gitlab/backups` which should be on a
-[volume mounted by Docker](installation.md#set-up-the-volumes-location).
+[volume mounted by Docker](installation.md#create-a-directory-for-the-volumes).
 
 For more information on using the backup to roll back an upgrade, see [Downgrade GitLab](upgrade.md#downgrade-gitlab).
diff --git a/doc/install/docker/configuration.md b/doc/install/docker/configuration.md
index 06da6734fcaac259029c1f5b1fa592bb0a4bef9a..f516bc3ccc7a9d539c56fc9bb8e8248f9b12b11a 100644
--- a/doc/install/docker/configuration.md
+++ b/doc/install/docker/configuration.md
@@ -174,7 +174,7 @@ Following the above example, you will be able to reach GitLab from your
 web browser under `<hostIP>:8929` and push using SSH under the port `2424`.
 
 A `docker-compose.yml` example that uses different ports can be found in the
-[Docker compose](installation.md#install-gitlab-using-docker-compose) section.
+[Docker compose](installation.md#install-gitlab-by-using-docker-compose) section.
 
 ## Configure multiple database connections
 
@@ -203,6 +203,6 @@ sudo docker restart gitlab
 
 ## Recommended next steps
 
-After completing your installation, consider taking the
+After configuring your installation, consider taking the
 [recommended next steps](../next_steps.md), including authentication options
 and sign-up restrictions.
diff --git a/doc/install/docker/index.md b/doc/install/docker/index.md
index f9813a5f219fbd5a44fc89fd6f665cd6021d4651..7625eca6b8a998a24a346333fa2668018c743a45 100644
--- a/doc/install/docker/index.md
+++ b/doc/install/docker/index.md
@@ -10,25 +10,17 @@ DETAILS:
 **Tier:** Free, Premium, Ultimate
 **Offering:** Self-managed
 
-The GitLab Docker images are monolithic images of GitLab running all the
+To run GitLab in a Docker container, use a GitLab image, which contains all of the
 necessary services in a single container.
 
-## Installation
+Find the GitLab official Docker images at:
 
-For installation options and details, see [Install GitLab in a Docker container](installation.md).
+- [GitLab Docker images in Docker Hub](https://hub.docker.com/r/gitlab/gitlab-ee/)
 
-## Configuration
+## Related topics
 
-To configure your GitLab installation on Docker, see [Configure GitLab running in a Docker container](configuration.md).
-
-## Backup and restore
-
-For information on backing and restoring your GitLab installation or database, see [Back up GitLab running in a Docker container](backup_restore.md).
-
-## Upgrade
-
-To upgrade GitLab, see [Upgrade GitLab running in a Docker container](upgrade.md).
-
-## Troubleshooting
-
-See [Troubleshooting GitLab installations that use Docker](../docker/troubleshooting.md).
+- [Install GitLab in a Docker container](installation.md)
+- [Configure GitLab running in a Docker container](configuration.md)
+- [Back up GitLab running in a Docker container](backup_restore.md)
+- [Upgrade GitLab running in a Docker container](upgrade.md)
+- [Troubleshooting GitLab running in a Docker container](../docker/troubleshooting.md)
diff --git a/doc/install/docker/installation.md b/doc/install/docker/installation.md
index fcc4642fe2db49154ed65aabfa60e6710f610dce..a0f697be73c6393d61b42a457c0ff85597412b5d 100644
--- a/doc/install/docker/installation.md
+++ b/doc/install/docker/installation.md
@@ -10,48 +10,43 @@ DETAILS:
 **Tier:** Free, Premium, Ultimate
 **Offering:** Self-managed
 
-Find the GitLab official Docker image at:
-
-- [GitLab Docker image in Docker Hub](https://hub.docker.com/r/gitlab/gitlab-ee/)
-
-The Docker images don't include a mail transport agent (MTA). The recommended
-solution is to add an MTA (such as Postfix or Sendmail) running in a separate
-container. As another option, you can install an MTA directly in the GitLab
-container, but this adds maintenance overhead as you'll likely need to reinstall
-the MTA after every upgrade or restart.
-
-You should not deploy the GitLab Docker image in Kubernetes as it creates a
-single point of failure. If you want to deploy GitLab in Kubernetes, the
+To install GitLab in a Docker container, use Docker Compose, Docker Engine, or Docker Swarm mode.
+
+Prerequisites:
+
+- You must have a working [Docker installation](https://docs.docker.com/engine/install/#server) that is not Docker for Windows.
+Docker for Windows is not officially supported as the images have known compatability issues with volume
+permissions and potentially other unknown issues. If you are trying to run on Docker
+for Windows, see the [getting help page](https://about.gitlab.com/get-help/). This page
+contains links to community resources (like IRC or forums) where you can seek help
+from other users.
+- You must have a mail transport agent (MTA), such as Postfix or Sendmail. The GitLab images don't include an MTA. You can
+install an MTA in a separate container. While you can install an MTA in the same container as GitLab, you might need to
+reinstall the MTA after every upgrade or restart.
+- You should not plan to deploy the GitLab Docker image in Kubernetes as it creates a
+single point of failure. If you want to deploy GitLab in Kubernetes, use the
 [GitLab Helm Chart](https://docs.gitlab.com/charts/) or [GitLab Operator](https://docs.gitlab.com/operator/)
-should be used instead.
-
-WARNING:
-Docker for Windows is not officially supported. There are known issues with volume
-permissions, and potentially other unknown issues. If you are trying to run on Docker
-for Windows, see the [getting help page](https://about.gitlab.com/get-help/) for links
-to community resources (such as IRC or forums) to seek help from other users.
-
-## Prerequisites
+instead.
+- You must have a valid, externally accessible hostname for your Docker installation. Do not use `localhost`.
 
-To use the GitLab Docker images:
+## Configure the SSH port
 
-- You must [install Docker](https://docs.docker.com/engine/install/#server).
-- You must use a valid externally-accessible hostname. Do not use `localhost`.
+By default, GitLab uses port `22` to interact with Git over SSH.
+To use port `22`, skip this section.
 
-### Configure the SSH port
+To use a different port, you can either:
 
-GitLab uses SSH to interact with Git over SSH. By default, GitLab uses port `22`.
+- Change the server's SSH port now (recommended). Then the SSH clone URLs don't need the new port number:
 
-To use a different port when using the GitLab Docker image, you can either:
+  ```plaintext
+  ssh://git@gitlab.example.com/user/project.git
+  ```
 
-- Change the server's SSH port (recommended).
-- Change the GitLab Shell SSH port.
+- [Change the GitLab Shell SSH port](configuration.md#expose-gitlab-on-different-ports) after installation. Then the SSH clone URLs include the configured port number:
 
-### Change the server's SSH port
-
-You can change the server's SSH port without making another SSH configuration
-change in GitLab. In that case, the SSH clone URLs looks like
-`ssh://git@gitlab.example.com/user/project.git`.
+  ```plaintext
+  ssh://git@gitlab.example.com:<portNumber>/user/project.git
+  ```
 
 To change the server's SSH port:
 
@@ -67,56 +62,50 @@ To change the server's SSH port:
    sudo systemctl restart ssh
    ```
 
-1. Open a new terminal session and verify that you can connect using SSH to the server using
+1. Verify that you can connect over SSH. Open a new terminal session and SSH to the server using
    the new port.
 
-### Change the GitLab Shell SSH port
-
-If you don't want to change the server's default SSH port, you can configure a
-different SSH port that GitLab uses for Git over SSH pushes. In that case,
-the SSH clone URLs looks like
-`ssh://git@gitlab.example.com:<portNumber>/user/project.git`.
-
-For more information, see how to [change the GitLab Shell SSH port](configuration.md#expose-gitlab-on-different-ports).
+## Create a directory for the volumes
 
-### Set up the volumes location
+Create a directory for the configuration files, logs,
+and data files. The directory can be in your user's home directory (for example
+`~/gitlab-docker`), or in a directory like `/srv/gitlab`.
 
-Before setting everything else, create a directory where the configuration, logs,
-and data files will reside. It can be under your user's home directory (for example
-`~/gitlab-docker`), or in a directory like `/srv/gitlab`. To create that directory:
+1. Create the directory:
 
-```shell
-sudo mkdir -p /srv/gitlab
-```
+   ```shell
+   sudo mkdir -p /srv/gitlab
+   ```
 
-If you're running Docker with a user other than `root`, ensure appropriate
-permissions have been granted to that directory.
+1. If you're running Docker with a user other than `root`, grant the appropriate
+   permissions to the user for the new directory.
 
-Configure a new environment variable `$GITLAB_HOME` that sets the path to the
-directory you created:
+1. Configure a new environment variable `$GITLAB_HOME` that sets the path to the
+   directory you created:
 
-```shell
-export GITLAB_HOME=/srv/gitlab
-```
+   ```shell
+   export GITLAB_HOME=/srv/gitlab
+   ```
 
-You can also append the `GITLAB_HOME` environment variable to your shell's
-profile so it is applied on all future terminal sessions:
+1. Optionally, you can append the `GITLAB_HOME` environment variable to your shell's
+   profile so it is applied on all future terminal sessions:
 
-- Bash: `~/.bash_profile`
-- ZSH: `~/.zshrc`
+   - Bash: `~/.bash_profile`
+   - ZSH: `~/.zshrc`
 
-The GitLab container uses host mounted volumes to store persistent data:
+The GitLab container uses host-mounted volumes to store persistent data:
 
 | Local location       | Container location | Usage                                       |
 |----------------------|--------------------|---------------------------------------------|
-| `$GITLAB_HOME/data`  | `/var/opt/gitlab`  | For storing application data.               |
-| `$GITLAB_HOME/logs`  | `/var/log/gitlab`  | For storing logs.                           |
-| `$GITLAB_HOME/config`| `/etc/gitlab`      | For storing the GitLab configuration files. |
+| `$GITLAB_HOME/data`  | `/var/opt/gitlab`  | Stores application data.                    |
+| `$GITLAB_HOME/logs`  | `/var/log/gitlab`  | Stores logs.                                |
+| `$GITLAB_HOME/config`| `/etc/gitlab`      | Stores the GitLab configuration files.      |
 
-### Find the GitLab version and edition to use
+## Find the GitLab version and edition to use
 
 In a production environment, you should pin your deployment to a specific
-GitLab version. Find the version to use in the Docker tags page:
+GitLab version. Review the available versions and choose the version you want to use in the
+Docker tags page:
 
 - [GitLab Enterprise Edition tags](https://hub.docker.com/r/gitlab/gitlab-ee/tags/)
 - [GitLab Community Edition tags](https://hub.docker.com/r/gitlab/gitlab-ce/tags/)
@@ -127,100 +116,33 @@ The tag name consists of the following:
 gitlab/gitlab-ee:<version>-ee.0
 ```
 
-Where `<version>` is the GitLab version, for example `16.5.3`. It always includes
+Where `<version>` is the GitLab version, for example `16.5.3`. The version always includes
 `<major>.<minor>.<patch>` in its name.
 
 For testing purposes, you can use the `latest` tag, such as `gitlab/gitlab-ee:latest`,
 which points to the latest stable release.
 
-In the following examples, we use a stable Enterprise Edition version, but
-if you want to use the Release Candidate (RC) or nightly image, use
+The following examples use a stable Enterprise Edition version.
+If you want to use the Release Candidate (RC) or nightly image, use
 `gitlab/gitlab-ee:rc` or `gitlab/gitlab-ee:nightly` instead.
 
 To install the Community Edition, replace `ee` with `ce`.
 
 ## Installation
 
-The GitLab Docker images can be run in multiple ways:
-
-- [Using Docker Engine](installation.md#install-gitlab-using-docker-engine)
-- [Using Docker Compose](installation.md#install-gitlab-using-docker-compose)
-- [Using Docker swarm mode](installation.md#install-gitlab-using-docker-swarm-mode)
-
-### Install GitLab using Docker Engine
-
-You can fine tune these directories to meet your requirements.
-Once you've set up the `GITLAB_HOME` variable, you can run the image:
-
-```shell
-sudo docker run --detach \
-  --hostname gitlab.example.com \
-  --env GITLAB_OMNIBUS_CONFIG="external_url 'http://gitlab.example.com'" \
-  --publish 443:443 --publish 80:80 --publish 22:22 \
-  --name gitlab \
-  --restart always \
-  --volume $GITLAB_HOME/config:/etc/gitlab \
-  --volume $GITLAB_HOME/logs:/var/log/gitlab \
-  --volume $GITLAB_HOME/data:/var/opt/gitlab \
-  --shm-size 256m \
-  gitlab/gitlab-ee:<version>-ee.0
-```
+You can run the GitLab Docker images by using:
 
-This command downloads and starts a GitLab container, and
-[publishes ports](https://docs.docker.com/network/#published-ports) needed to
-access SSH, HTTP and HTTPS. All GitLab data are stored as subdirectories of
-`$GITLAB_HOME`. The container automatically restarts after a system reboot.
-
-If you are on SELinux, then run this instead:
-
-```shell
-sudo docker run --detach \
-  --hostname gitlab.example.com \
-  --env GITLAB_OMNIBUS_CONFIG="external_url 'http://gitlab.example.com'" \
-  --publish 443:443 --publish 80:80 --publish 22:22 \
-  --name gitlab \
-  --restart always \
-  --volume $GITLAB_HOME/config:/etc/gitlab:Z \
-  --volume $GITLAB_HOME/logs:/var/log/gitlab:Z \
-  --volume $GITLAB_HOME/data:/var/opt/gitlab:Z \
-  --shm-size 256m \
-  gitlab/gitlab-ee:<version>-ee.0
-```
-
-This command ensures that the Docker process has enough permissions to create the
-configuration files in the mounted volumes.
+- [Docker Compose](#install-gitlab-by-using-docker-compose) (recommended)
+- [Docker Engine](#install-gitlab-by-using-docker-engine)
+- [Docker Swarm mode](#install-gitlab-by-using-docker-swarm-mode)
 
-If you're using the [Kerberos integration](../../integration/kerberos.md),
-you must also publish your Kerberos port (for example, `--publish 8443:8443`).
-Failing to do so prevents Git operations with Kerberos.
+### Install GitLab by using Docker Compose
 
-The initialization process may take a long time. You can track this
-process with:
-
-```shell
-sudo docker logs -f gitlab
-```
-
-After starting the container, you can visit `gitlab.example.com`. It might take
-a while before the Docker container starts to respond to queries.
-
-Visit the GitLab URL, and sign in with the username `root`
-and the password from the following command:
-
-```shell
-sudo docker exec -it gitlab grep 'Password:' /etc/gitlab/initial_root_password
-```
-
-NOTE:
-The password file is automatically deleted in the first container restart after 24 hours.
-
-### Install GitLab using Docker Compose
-
-With [Docker Compose](https://docs.docker.com/compose/) you can easily configure,
+With [Docker Compose](https://docs.docker.com/compose/) you can configure,
 install, and upgrade your Docker-based GitLab installation:
 
 1. [Install Docker Compose](https://docs.docker.com/compose/install/linux/).
-1. Create a `docker-compose.yml` file:
+1. Create a `docker-compose.yml` file. For example:
 
    ```yaml
    version: '3.6'
@@ -245,53 +167,122 @@ install, and upgrade your Docker-based GitLab installation:
        shm_size: '256m'
    ```
 
-1. Make sure you are in the same directory as `docker-compose.yml` and start
-   GitLab:
+   NOTE:
+   Read the [Pre-configure Docker container](configuration.md#pre-configure-docker-container) section
+   to see how the `GITLAB_OMNIBUS_CONFIG` variable works.
+
+   Here is another `docker-compose.yml` example with GitLab running on a custom
+   HTTP and SSH port. Notice that the `GITLAB_OMNIBUS_CONFIG` variables match the
+   `ports` section:
+
+   ```yaml
+   version: '3.6'
+   services:
+     gitlab:
+       image: gitlab/gitlab-ee:<version>-ee.0
+       container_name: gitlab
+       restart: always
+       hostname: 'gitlab.example.com'
+       environment:
+         GITLAB_OMNIBUS_CONFIG: |
+           external_url 'http://gitlab.example.com:8929'
+           gitlab_rails['gitlab_shell_ssh_port'] = 2424
+       ports:
+         - '8929:8929'
+         - '443:443'
+         - '2424:22'
+       volumes:
+         - '$GITLAB_HOME/config:/etc/gitlab'
+         - '$GITLAB_HOME/logs:/var/log/gitlab'
+         - '$GITLAB_HOME/data:/var/opt/gitlab'
+       shm_size: '256m'
+   ```
+
+   This configuration is the same as using `--publish 8929:8929 --publish 2424:22`.
+
+1. In the same directory as `docker-compose.yml`, start GitLab:
 
    ```shell
    docker compose up -d
    ```
 
-NOTE:
-Read the [Pre-configure Docker container](configuration.md#pre-configure-docker-container) section
-to see how the `GITLAB_OMNIBUS_CONFIG` variable works.
-
-Below is another `docker-compose.yml` example with GitLab running on a custom
-HTTP and SSH port. Notice how the `GITLAB_OMNIBUS_CONFIG` variables match the
-`ports` section:
-
-```yaml
-version: '3.6'
-services:
-  gitlab:
-    image: gitlab/gitlab-ee:<version>-ee.0
-    container_name: gitlab
-    restart: always
-    hostname: 'gitlab.example.com'
-    environment:
-      GITLAB_OMNIBUS_CONFIG: |
-        external_url 'http://gitlab.example.com:8929'
-        gitlab_rails['gitlab_shell_ssh_port'] = 2424
-    ports:
-      - '8929:8929'
-      - '443:443'
-      - '2424:22'
-    volumes:
-      - '$GITLAB_HOME/config:/etc/gitlab'
-      - '$GITLAB_HOME/logs:/var/log/gitlab'
-      - '$GITLAB_HOME/data:/var/opt/gitlab'
-    shm_size: '256m'
-```
+### Install GitLab by using Docker Engine
+
+Alternatively, you can install GitLab using Docker Engine.
+
+1. If you've set up the `GITLAB_HOME` variable, adjust the directories to meet your requirements
+and run the image:
+
+   - If you are not on SELinux, run this command:
+
+      ```shell
+      sudo docker run --detach \
+        --hostname gitlab.example.com \
+        --env GITLAB_OMNIBUS_CONFIG="external_url 'http://gitlab.example.com'" \
+        --publish 443:443 --publish 80:80 --publish 22:22 \
+        --name gitlab \
+        --restart always \
+        --volume $GITLAB_HOME/config:/etc/gitlab \
+        --volume $GITLAB_HOME/logs:/var/log/gitlab \
+        --volume $GITLAB_HOME/data:/var/opt/gitlab \
+        --shm-size 256m \
+        gitlab/gitlab-ee:<version>-ee.0
+      ```
+
+      This command downloads and starts a GitLab container, and
+      [publishes ports](https://docs.docker.com/network/#published-ports) needed to
+      access SSH, HTTP and HTTPS. All GitLab data are stored as subdirectories of
+      `$GITLAB_HOME`. The container automatically restarts after a system reboot.
+
+   - If you are on SELinux, then run this instead:
+
+     ```shell
+      sudo docker run --detach \
+        --hostname gitlab.example.com \
+        --env GITLAB_OMNIBUS_CONFIG="external_url 'http://gitlab.example.com'" \
+        --publish 443:443 --publish 80:80 --publish 22:22 \
+        --name gitlab \
+        --restart always \
+        --volume $GITLAB_HOME/config:/etc/gitlab:Z \
+        --volume $GITLAB_HOME/logs:/var/log/gitlab:Z \
+        --volume $GITLAB_HOME/data:/var/opt/gitlab:Z \
+        --shm-size 256m \
+        gitlab/gitlab-ee:<version>-ee.0
+      ```
+
+      This command ensures that the Docker process has enough permissions to create the configuration
+      files in the mounted volumes.
+
+1. If you're using the [Kerberos integration](../../integration/kerberos.md),
+you must also publish your Kerberos port (for example, `--publish 8443:8443`).
+Failing to do so prevents Git operations with Kerberos.
+The initialization process may take a long time. You can track this
+process with:
+
+   ```shell
+   sudo docker logs -f gitlab
+   ```
 
-This configuration is the same as using `--publish 8929:8929 --publish 2424:22`.
+   After starting the container, you can visit `gitlab.example.com`. It might take
+   a while before the Docker container starts to respond to queries.
 
-### Install GitLab using Docker swarm mode
+1. Visit the GitLab URL, and sign in with the username `root`
+and the password from the following command:
 
-With [Docker swarm mode](https://docs.docker.com/engine/swarm/), you can easily
-configure and deploy your
-Docker-based GitLab installation in a swarm cluster.
+   ```shell
+   sudo docker exec -it gitlab grep 'Password:' 
+   /etc/gitlab/initial_root_password
+   ```
 
-In swarm mode you can leverage [Docker secrets](https://docs.docker.com/engine/swarm/secrets/)
+NOTE:
+The password file is automatically deleted in the first container restart after 24 hours.
+
+### Install GitLab by using Docker Swarm mode
+
+With [Docker Swarm mode](https://docs.docker.com/engine/swarm/), you can
+configure and deploy your GitLab installation with Docker in a swarm cluster.
+
+In swarm mode, you can leverage [Docker secrets](https://docs.docker.com/engine/swarm/secrets/)
 and [Docker configurations](https://docs.docker.com/engine/swarm/configs/) to efficiently and securely deploy your GitLab instance.
 Secrets can be used to securely pass your initial root password without exposing it as an environment variable.
 Configurations can help you to keep your GitLab image as generic as possible.
@@ -338,8 +329,8 @@ Here's an example that deploys GitLab with four runners as a [stack](https://doc
        file: ./root_password.txt
    ```
 
-   For simplicity reasons, the `network` configuration was omitted.
-   More information can be found in the official [Compose file reference](https://docs.docker.com/compose/compose-file/).
+   To reduce complexity, the example above excludes the `network` configuration.
+   You can find more information in the official [Compose file reference](https://docs.docker.com/compose/compose-file/).
 
 1. Create a `gitlab.rb` file:
 
@@ -359,3 +350,5 @@ Here's an example that deploys GitLab with four runners as a [stack](https://doc
    ```shell
    docker stack deploy --compose-file docker-compose.yml mystack
    ```
+
+After you've installed Docker, you need to [configure your GitLab instance](configuration.md).
diff --git a/doc/install/docker/upgrade.md b/doc/install/docker/upgrade.md
index 76913a654298e9c17f1891725023c59299023edc..436afa0e58ce89fd2469c2f4686619eb01f4357c 100644
--- a/doc/install/docker/upgrade.md
+++ b/doc/install/docker/upgrade.md
@@ -15,7 +15,7 @@ image tag.
 
 ## Upgrade GitLab using Docker Engine
 
-To upgrade GitLab that was [installed using Docker Engine](installation.md#install-gitlab-using-docker-engine):
+To upgrade GitLab that was [installed using Docker Engine](installation.md#install-gitlab-by-using-docker-engine):
 
 1. Take a [backup](backup_restore.md). As a minimum, back up [the database](backup_restore.md#create-a-database-backup) and
    the GitLab secrets file.
@@ -38,14 +38,14 @@ To upgrade GitLab that was [installed using Docker Engine](installation.md#insta
    sudo docker pull gitlab/gitlab-ee:<version>-ee.0
    ```
 
-1. Ensure that the `GITLAB_HOME` environment variable is [defined](installation.md#set-up-the-volumes-location):
+1. Ensure that the `GITLAB_HOME` environment variable is [defined](installation.md#create-a-directory-for-the-volumes):
 
    ```shell
    echo $GITLAB_HOME
    ```
 
 1. Create the container once again with the
-   [previously specified](installation.md#install-gitlab-using-docker-engine) options:
+   [previously specified](installation.md#install-gitlab-by-using-docker-engine) options:
 
    ```shell
    sudo docker run --detach \
@@ -67,7 +67,7 @@ when upgrading between versions.
 
 ## Upgrade GitLab using Docker compose
 
-To upgrade GitLab that was [installed using Docker Compose](installation.md#install-gitlab-using-docker-compose):
+To upgrade GitLab that was [installed using Docker Compose](installation.md#install-gitlab-by-using-docker-compose):
 
 1. Take a [backup](backup_restore.md). As a minimum, back up [the database](backup_restore.md#create-a-database-backup) and
    the GitLab secrets file.