docker-elk Documentation

The Elastic stack (ELK) powered by Docker and Compose.

18,387 stars Shell Shell 1 file ยท ~7,508 tokens #docker#docker-compose#elasticsearch#elk#kibana#logstash#searchguard
RAW Doc

Docker & Self-Hosted Deployment Verified OCI

Deploy docker-elk on any server, homelab, or cloud container platform.

1-Click Terminal Command
bash (docker run) 
docker run -d --name docker-elk -p 9200:9200 --restart always deviantony/docker-elk:latest
Configured Services & Ports
โš™๏ธ setup
image: build locally
โš™๏ธ kibana-genkeys
image: build locally
โš™๏ธ elasticsearch
image: build locally
๐Ÿ”Œ Ports: 9200:9200, 9300:9300
โš™๏ธ logstash
image: build locally
๐Ÿ”Œ Ports: 5044:5044, 50000:50000/tcp, 50000:50000/udp, 9600:9600
โš™๏ธ kibana
image: build locally
๐Ÿ”Œ Ports: 5601:5601
docker-compose.yml
yaml (docker-compose.yml) 
services:

  # The 'setup' service runs a one-off script which initializes users inside
  # Elasticsearch โ€” such as 'logstash_internal' and 'kibana_system' โ€” with the
  # values of the passwords defined in the '.env' file. It also creates the
  # roles required by some of these users.
  #
  # This task only needs to be performed once, during the *initial* startup of
  # the stack. Any subsequent run will reset the passwords of existing users to
  # the values defined inside the '.env' file, and the built-in roles to their
  # default permissions.
  #
  # By default, it is excluded from the services started by 'docker compose up'
  # due to the non-default profile it belongs to. To run it, either provide the
  # '--profile=setup' CLI flag to Compose commands, or "up" the service by name
  # such as 'docker compose up setup'.
  setup:
    profiles:
      - setup
    build:
      context: setup/
      args:
        ELASTIC_VERSION: ${ELASTIC_VERSION}
    init: true
    volumes:
      - ./setup/entrypoint.sh:/entrypoint.sh:ro,Z
      - ./setup/lib.sh:/lib.sh:ro,Z
      - ./setup/roles:/roles:ro,Z
    environment:
      ELASTIC_PASSWORD: ${ELASTIC_PASSWORD:-}
      LOGSTASH_INTERNAL_PASSWORD: ${LOGSTASH_INTERNAL_PASSWORD:-}
      KIBANA_SYSTEM_PASSWORD: ${KIBANA_SYSTEM_PASSWORD:-}
      METRICBEAT_INTERNAL_PASSWORD: ${METRICBEAT_INTERNAL_PASSWORD:-}
      FILEBEAT_INTERNAL_PASSWORD: ${FILEBEAT_INTERNAL_PASSWORD:-}
      HEARTBEAT_INTERNAL_PASSWORD: ${HEARTBEAT_INTERNAL_PASSWORD:-}
      MONITORING_INTERNAL_PASSWORD: ${MONITORING_INTERNAL_PASSWORD:-}
      BEATS_SYSTEM_PASSWORD: ${BEATS_SYSTEM_PASSWORD:-}
    network_mode: service:elasticsearch
    depends_on:
      - elasticsearch

  # The 'kibana-genkeys' service runs a one-off command which generates and
  # prints encryption keys for Kibana.
  #
  # By default, it is excluded from the services started by 'docker compose up'
  # due to the non-default profile it belongs to. To run it, either provide the
  # '--profile=setup' CLI flag to Compose commands, or "up" the service by name
  # such as 'docker compose up kibana-genkeys'.
  kibana-genkeys:
    profiles:
      - setup
    build:
      context: kibana/
      args:
        ELASTIC_VERSION: ${ELASTIC_VERSION}
    command:
      - bin/kibana-encryption-keys
      - generate
    network_mode: none

  elasticsearch:
    build:
      context: elasticsearch/
      args:
        ELASTIC_VERSION: ${ELASTIC_VERSION}
    volumes:
      - ./elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml:ro,Z
      - elasticsearch:/usr/share/elasticsearch/data:Z
    ports:
      - 9200:9200
      - 9300:9300
    environment:
      node.name: elasticsearch
      ES_JAVA_OPTS: -Xms512m -Xmx512m
      # Bootstrap password.
      # Used to initialize the keystore during the initial startup of
      # Elasticsearch. Ignored on subsequent runs.
      ELASTIC_PASSWORD: ${ELASTIC_PASSWORD:-}
      # Use single node discovery in order to disable production mode and avoid bootstrap checks.
      # see: https://www.elastic.co/docs/deploy-manage/deploy/self-managed/bootstrap-checks
      discovery.type: single-node
    networks:
      - elk
    restart: unless-stopped

  logstash:
    build:
      context: logstash/
      args:
        ELASTIC_VERSION: ${ELASTIC_VERSION}
    volumes:
      - ./logstash/config/logstash.yml:/usr/share/logstash/config/logstash.yml:ro,Z
      - ./logstash/pipeline:/usr/share/logstash/pipeline:ro,Z
    ports:
      - 5044:5044
      - 50000:50000/tcp
      - 50000:50000/udp
      - 9600:9600
    environment:
      LS_JAVA_OPTS: -Xms256m -Xmx256m
      LOGSTASH_INTERNAL_PASSWORD: ${LOGSTASH_INTERNAL_PASSWORD:-}
    networks:
      - elk
    depends_on:
      - elasticsearch
    restart: unless-stopped

  kibana:
    build:
      context: kibana/
      args:
        ELASTIC_VERSION: ${ELASTIC_VERSION}
    volumes:
      - ./kibana/config/kibana.yml:/usr/share/kibana/config/kibana.yml:ro,Z
    ports:
      - 5601:5601
    environment:
      KIBANA_SYSTEM_PASSWORD: ${KIBANA_SYSTEM_PASSWORD:-}
    networks:
      - elk
    depends_on:
      - elasticsearch
    restart: unless-stopped

networks:
  elk:
    driver: bridge

volumes:
  elasticsearch:

File: README.md

Elastic stack (ELK) on Docker


Run the latest version of the Elastic stack with Docker and Docker Compose.

It gives you the ability to analyze any data set by using the searching/aggregation capabilities of Elasticsearch and
the visualization power of Kibana.

Based on the official Docker images from Elastic:

Other available stack variants:

  • tls: TLS encryption enabled in Elasticsearch, Kibana (opt in),
    and Fleet

[!IMPORTANT]
Platinum features are enabled by default for a trial duration of 30 days. After
this evaluation period, you will retain access to all the free features included in the Open Basic license seamlessly,
without manual intervention required, and without losing any data. Refer to the How to disable paid
features section to opt out of this behaviour.

tl;dr

sh
docker compose up setup
sh
docker compose up

Philosophy

The main goal of docker-elk is to make the Elastic stack as easy as possible to get into. It is not a blueprint for a
production-ready deployment, but rather a template that promotes tweaking and exploration.

The authors believe in good documentation over elaborate automation. The project's default configuration is purposely
minimal and unopinionated. The initial setup does not rely on any external dependency, and uses as little scripting as
necessary to get things up and running.

Contents

  1. Requirements
  2. Usage
  3. Configuration
  4. Extensibility
  5. JVM tuning
  6. Going further

Requirements

Host setup

[!NOTE]
Especially on Linux, make sure your user has the required permissions to interact with the Docker
daemon.

By default, the stack exposes the following ports:

  • 5044: Logstash Beats input
  • 50000: Logstash TCP input
  • 9600: Logstash monitoring API
  • 9200: Elasticsearch HTTP
  • 9300: Elasticsearch TCP transport
  • 5601: Kibana

[!WARNING]
Elasticsearch's bootstrap checks were purposely disabled to facilitate the setup of the Elastic
stack in development environments. For production setups, we recommend users to set up their host according to the
instructions from the Elasticsearch documentation: Important System Configuration.

Docker Desktop

Windows

If you are using the legacy Hyper-V mode of Docker Desktop for Windows, ensure that File
Sharing is enabled for the C: drive.

macOS

The default configuration of Docker Desktop for Mac allows mounting files from /Users/, /Volume/, /private/,
/tmp and /var/folders exclusively. Make sure the repository is cloned in one of those locations or follow the
instructions from the documentation to add more locations.

Usage

[!WARNING]
You must rebuild the stack images with docker compose build whenever you switch branch or update the
version of an already existing stack.

Bringing up the stack

Clone this repository onto the Docker host that will run the stack with the command below:

sh
git clone https://github.com/deviantony/docker-elk.git

Then, initialize the Elasticsearch users and groups required by docker-elk by executing the command:

sh
docker compose up setup

Optionally (but highly recommended), generate encryption keys for Kibana using the following command and copy its output
to the Kibana configuration file (kibana/config/kibana.yml):

sh
docker compose up kibana-genkeys

If everything went well and the setup completed without error, start the other stack components:

sh
docker compose up

[!NOTE]
You can also run all services in the background (detached mode) by appending the -d flag to the above command.

Give Kibana about a minute to initialize, then access the Kibana web UI by opening http://localhost:5601 in a web
browser and use the following (default) credentials to log in:

  • user: elastic
  • password: changeme

[!NOTE]
Upon the initial startup, the elastic, logstash_internal and kibana_system Elasticsearch users are initialized
with the values of the passwords defined in the .env file ("changeme" by default). The first one is the
built-in superuser, the other two are used by Kibana and Logstash respectively to communicate with
Elasticsearch. This task is only performed during the initial startup of the stack. To change users' passwords
after they have been initialized, please refer to the instructions in the next section.

Initial setup

Setting up user authentication

[!NOTE]
Refer to Security settings in Elasticsearch to disable authentication.

[!WARNING]
Starting with Elastic v8.0.0, it is no longer possible to run Kibana using the bootstrapped privileged elastic user.

The "changeme" password set by default for all aforementioned users is unsecure. For increased security, we will
reset the passwords of all aforementioned Elasticsearch users to random secrets.

  1. Reset passwords for default users

    The commands below reset the passwords of the elastic, logstash_internal and kibana_system users. Take note
    of them.

    sh
    docker compose exec elasticsearch bin/elasticsearch-reset-password --batch --user elastic
    sh
    docker compose exec elasticsearch bin/elasticsearch-reset-password --batch --user logstash_internal
    sh
    docker compose exec elasticsearch bin/elasticsearch-reset-password --batch --user kibana_system

    If the need for it arises (e.g. if you want to collect monitoring information through Beats and
    other components), feel free to repeat this operation at any time for the rest of the built-in
    users    .

  2. Replace usernames and passwords in configuration files

    Replace the password of the elastic user inside the .env file with the password generated in the previous step.
    Its value isn't used by any core component, but extensions use it to
    connect to Elasticsearch.

    [!NOTE]
    In case you don't plan on using any of the provided extensions, or
    prefer to create your own roles and users to authenticate these services, it is safe to remove the
    ELASTIC_PASSWORD entry from the .env file altogether after the stack has been initialized.

    Replace the password of the logstash_internal user inside the .env file with the password generated in the
    previous step. Its value is referenced inside the Logstash pipeline file (logstash/pipeline/logstash.conf).

    Replace the password of the kibana_system user inside the .env file with the password generated in the previous
    step. Its value is referenced inside the Kibana configuration file (kibana/config/kibana.yml).

    See the Configuration section below for more information about these configuration files.

  3. Restart Logstash and Kibana to re-connect to Elasticsearch using the new passwords

    sh
    docker compose up -d logstash kibana

[!NOTE]
Learn more about the security of the Elastic stack at Secure the Elastic Stack.

Injecting data

Launch the Kibana web UI by opening http://localhost:5601 in a web browser, and use the following credentials to log
in:

  • user: elastic
  • password: <your generated elastic password>

Now that the stack is fully configured, you can go ahead and inject some log entries.

The shipped Logstash configuration allows you to send data over the TCP port 50000. For example, you can use one of the
following commands โ€” depending on your installed version of nc (Netcat) โ€” to ingest the content of the log file
/path/to/logfile.log in Elasticsearch, via Logstash:

sh
# Execute `nc -h` to determine your `nc` version

cat /path/to/logfile.log | nc -q0 localhost 50000          # BSD
cat /path/to/logfile.log | nc -c localhost 50000           # GNU
cat /path/to/logfile.log | nc --send-only localhost 50000  # nmap

You can also load the sample data provided by your Kibana installation.

Cleanup

Elasticsearch data is persisted inside a volume by default.

In order to entirely shutdown the stack and remove all persisted data, use the following Docker Compose command:

sh
docker compose --profile=setup down -v

Version selection

This repository stays aligned with the latest version of the Elastic stack. The main branch tracks the current major
version (9.x).

To use a different version of the core Elastic components, simply change the version number inside the .env
file. If you are upgrading an existing stack, remember to rebuild all container images using the docker compose build
command.

[!IMPORTANT]
Always pay attention to the official upgrade instructions for each individual component before performing a
stack upgrade.

Older major versions are also supported on separate branches:

Configuration

[!IMPORTANT]
Configuration is not dynamically reloaded, you will need to restart individual components after any configuration
change.

How to configure Elasticsearch

The Elasticsearch configuration is stored in elasticsearch/config/elasticsearch.yml.

You can also specify the options you want to override by setting environment variables inside the Compose file:

yml
elasticsearch:

  environment:
    network.host: _non_loopback_
    cluster.name: my-cluster

Please refer to the following documentation page for more details about how to configure Elasticsearch inside Docker
containers: Install Elasticsearch with Docker.

How to configure Kibana

The Kibana default configuration is stored in kibana/config/kibana.yml.

You can also specify the options you want to override by setting environment variables inside the Compose file:

yml
kibana:

  environment:
    SERVER_NAME: kibana.example.org

Please refer to the following documentation page for more details about how to configure Kibana inside Docker
containers: Install Kibana with Docker.

How to configure Logstash

The Logstash configuration is stored in logstash/config/logstash.yml.

You can also specify the options you want to override by setting environment variables inside the Compose file:

yml
logstash:

  environment:
    LOG_LEVEL: debug

Please refer to the following documentation page for more details about how to configure Logstash inside Docker
containers: Configuring Logstash for Docker.

How to disable paid features

You can cancel an ongoing trial before its expiry date โ€” and thus revert to a basic license โ€” either from the License
Management panel of Kibana, or using Elasticsearch's start_basic Licensing API. Please
note that the second option is the only way to recover access to Kibana if the license isn't either switched to basic
or upgraded before the trial's expiry date.

Changing the license type by switching the value of Elasticsearch's xpack.license.self_generated.type setting from
trial to basic (see License settings) will only work if done prior to the initial setup.
After a trial has been started, the loss of features from trial to basic must be acknowledged using one of the two
methods described in the first paragraph.

How to scale out the Elasticsearch cluster

Follow the instructions from the Wiki: Scaling out Elasticsearch

How to re-execute the setup

To run the setup container again and re-initialize all users for which a password was defined inside the .env file,
simply "up" the setup Compose service again:

console
$ docker compose up setup
 โ ฟ Container docker-elk-elasticsearch-1  Running
 โ ฟ Container docker-elk-setup-1          Created
Attaching to docker-elk-setup-1
...
docker-elk-setup-1  | [+] User 'monitoring_internal'
docker-elk-setup-1  |    โ ฟ User does not exist, creating
docker-elk-setup-1  | [+] User 'beats_system'
docker-elk-setup-1  |    โ ฟ User exists, setting password
docker-elk-setup-1 exited with code 0

How to reset a password programmatically

If for any reason your are unable to use Kibana to change the password of your users (including built-in
users), you can use the Elasticsearch API instead and achieve the same result.

In the example below, we reset the password of the elastic user (notice "/user/elastic" in the URL):

sh
curl -XPOST -D- 'http://localhost:9200/_security/user/elastic/_password' \
    -H 'Content-Type: application/json' \
    -u elastic:<your current elastic password> \
    -d '{"password" : "<your new password>"}'

Extensibility

How to add plugins

To add plugins to any ELK component you have to:

  1. Add a RUN statement to the corresponding Dockerfile (eg. RUN logstash-plugin install logstash-filter-json)
  2. Add the associated plugin code configuration to the service configuration (eg. Logstash input/output)
  3. Rebuild the images using the docker compose build command

How to enable the provided extensions

A few extensions are available inside the extensions directory. These extensions provide features which
are not part of the standard Elastic stack, but can be used to enrich it with extra integrations.

The documentation for these extensions is provided inside each individual subdirectory, on a per-extension basis. Some
of them require manual changes to the default ELK configuration.

JVM tuning

How to specify the amount of memory used by a service

The startup scripts for Elasticsearch and Logstash can append extra JVM options from the value of an environment
variable, allowing the user to adjust the amount of memory that can be used by each component:

Service Environment variable
Elasticsearch ES_JAVA_OPTS
Logstash LS_JAVA_OPTS

To accommodate environments where memory is scarce (Docker Desktop for Mac has only 2 GB available by default), the Heap
Size allocation is capped by default in the docker-compose.yml file to 512 MB for Elasticsearch and 256 MB for
Logstash. If you want to override the default JVM configuration, edit the matching environment variable(s) in the
docker-compose.yml file.

For example, to increase the maximum JVM Heap Size for Logstash:

yml
logstash:

  environment:
    LS_JAVA_OPTS: -Xms1g -Xmx1g

When these options are not set:

  • Elasticsearch starts with a JVM Heap Size that is determined automatically.
  • Logstash starts with a fixed JVM Heap Size of 1 GB.

How to enable a remote JMX connection to a service

As for the Java Heap memory (see above), you can specify JVM options to enable JMX and map the JMX port on the Docker
host.

Update the {ES,LS}_JAVA_OPTS environment variable with the following content (I've mapped the JMX service on the port
18080, you can change that). Do not forget to update the -Djava.rmi.server.hostname option with the IP address of your
Docker host (replace DOCKER_HOST_IP):

yml
logstash:

  environment:
    LS_JAVA_OPTS: -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.port=18080 -Dcom.sun.management.jmxremote.rmi.port=18080 -Djava.rmi.server.hostname=DOCKER_HOST_IP -Dcom.sun.management.jmxremote.local.only=false

Going further

Plugins and integrations

See the following Wiki pages:

File: extensions/metricbeat/README.md

Metricbeat

Metricbeat is a lightweight shipper that you can install on your servers to periodically collect metrics from the
operating system and from services running on the server. Metricbeat takes the metrics and statistics that it collects
and ships them to the output that you specify, such as Elasticsearch or Logstash.

Usage

This extension requires the metricbeat_internal, monitoring_internal and beats_system users to be created and
initialized with a password. In case you haven't done that during the initial startup of the stack, please refer to
How to re-execute the setup to run the setup container again and initialize these users.

To include Metricbeat in the stack, run Docker Compose from the root of the repository with an additional command line
argument referencing the metricbeat-compose.yml file:

console
$ docker compose -f docker-compose.yml -f extensions/metricbeat/metricbeat-compose.yml up

Configuring Metricbeat

The Metricbeat configuration is stored in config/metricbeat.yml. You can modify this file
with the help of the Configuration reference.

Any change to the Metricbeat configuration requires a restart of the Metricbeat container:

console
$ docker compose -f docker-compose.yml -f extensions/metricbeat/metricbeat-compose.yml restart metricbeat

Please refer to the following documentation page for more details about how to configure Metricbeat inside a
Docker container: Run Metricbeat on Docker.

See also

Metricbeat documentation

Screenshots

stack-monitoring
host-dashboard

File: extensions/heartbeat/README.md

Heartbeat

Heartbeat is a lightweight daemon that periodically checks the status of your services and determines whether they are
available.

Usage

This extension requires the heartbeat_internal and beats_system users to be created and initialized with a
password. In case you haven't done that during the initial startup of the stack, please refer to How to re-execute
the setup to run the setup container again and initialize these users.

To include Heartbeat in the stack, run Docker Compose from the root of the repository with an additional command line
argument referencing the heartbeat-compose.yml file:

console
$ docker compose -f docker-compose.yml -f extensions/heartbeat/heartbeat-compose.yml up

Configuring Heartbeat

The Heartbeat configuration is stored in config/heartbeat.yml. You can modify this file
with the help of the Configuration reference.

Any change to the Heartbeat configuration requires a restart of the Heartbeat container:

console
$ docker compose -f docker-compose.yml -f extensions/heartbeat/heartbeat-compose.yml restart heartbeat

Please refer to the following documentation page for more details about how to configure Heartbeat inside a
Docker container: Run Heartbeat on Docker.

See also

Heartbeat documentation

File: extensions/fleet/README.md

Fleet Server

[!WARNING]
This extension currently exists for preview purposes and should be considered EXPERIMENTAL. Expect regular changes
to the default Fleet settings, both in the Elastic Agent and Kibana.

See Known Issues for a list of issues that need to be addressed before this extension can be
considered functional.

Fleet provides central management capabilities for Elastic Agents via an API and web UI served by Kibana,
with Elasticsearch acting as the communication layer.
Fleet Server is the central component which allows connecting Elastic Agents to the Fleet.

Requirements

The Fleet Server exposes the TCP port 8220 for Agent to Server communications.

Usage

To include Fleet Server in the stack, run Docker Compose from the root of the repository with an additional command line
argument referencing the fleet-compose.yml file:

console
$ docker compose -f docker-compose.yml -f extensions/fleet/fleet-compose.yml up

Configuring Fleet Server

Fleet Server โ€” like any Elastic Agent โ€” is configured via Agent Policies which can be either managed
through the Fleet management UI in Kibana, or statically pre-configured inside the Kibana configuration file.

To ease the enrollment of Fleet Server in this extension, docker-elk comes with a pre-configured Agent Policy for Fleet
Server defined inside kibana/config/kibana.yml.

Please refer to the following documentation page for more details about configuring Fleet Server through the Fleet
management UI: Fleet UI Settings.

Known Issues

  • The Elastic Agent auto-enrolls using the elastic super-user. With this approach, you do not need to generate a
    service token โ€” either using the Fleet management UI or CLI utility โ€” prior to starting this
    extension. However convenient that is, this approach does not follow security best practices, and we recommend
    generating a service token for Fleet Server instead.

See also

Fleet and Elastic Agent Guide

Screenshots

fleet-agents
elastic-agent-dashboard

File: extensions/filebeat/README.md

Filebeat

Filebeat is a lightweight shipper for forwarding and centralizing log data. Installed as an agent on your servers,
Filebeat monitors the log files or locations that you specify, collects log events, and forwards them either to
Elasticsearch or Logstash for indexing.

Usage

This extension requires the filebeat_internal and beats_system users to be created and initialized with a
password. In case you haven't done that during the initial startup of the stack, please refer to How to re-execute
the setup to run the setup container again and initialize these users.

To include Filebeat in the stack, run Docker Compose from the root of the repository with an additional command line
argument referencing the filebeat-compose.yml file:

console
$ docker compose -f docker-compose.yml -f extensions/filebeat/filebeat-compose.yml up

Configuring Filebeat

The Filebeat configuration is stored in config/filebeat.yml. You can modify this file with
the help of the Configuration reference.

Any change to the Filebeat configuration requires a restart of the Filebeat container:

console
$ docker compose -f docker-compose.yml -f extensions/filebeat/filebeat-compose.yml restart filebeat

Please refer to the following documentation page for more details about how to configure Filebeat inside a Docker
container: Run Filebeat on Docker.

See also

Filebeat documentation

File: extensions/curator/README.md

Curator

Elasticsearch Curator helps you curate or manage your indices.

Usage

If you want to include the Curator extension, run Docker Compose from the root of the repository with an additional
command line argument referencing the curator-compose.yml file:

bash
$ docker compose -f docker-compose.yml -f extensions/curator/curator-compose.yml up

This sample setup demonstrates how to run curator every minute using cron.

All configuration files are available in the config/ directory.

Documentation

Curator Reference

File: extensions/README.md

Extensions

Third-party extensions that enable extra integrations with the Elastic stack.

Explore Related Technologies & Topics

View All 9,111+ Repositories โ†’

Discover similar high-velocity repositories, agent skills, and OpenAPI specifications across the ecosystem.

#docker Browse docker catalog โ†’ #docker-compose Browse docker-compose catalog โ†’ #elasticsearch Browse elasticsearch catalog โ†’ #elk Browse elk catalog โ†’ #kibana Browse kibana catalog โ†’ #logstash Browse logstash catalog โ†’ โšก MCP Servers Model Context Protocol โ†’ ๐Ÿง  Agent Skills Prompt & rule files โ†’ ๐Ÿ”Œ OpenAPI Specs REST & Swagger schemas โ†’