Linux Tutorials

Graylog 7 Web Interface Tour: Navigation and First Steps

Your first hour in the Graylog 7 web interface means two logins, a certificate wizard and an input that ignores you until a second wizard finishes. None of it is hard, but the screens do not tell you which password goes where, so most first-time setups stall at the login page. By the end of this tour you’ll have logs arriving, a stream and a search that finds them, a dashboard widget and an alert that fires on errors.

Original content from computingforgeeks.com - post 165897

It picks up where the guides to install Graylog 7 on Ubuntu and Debian, Rocky Linux and AlmaLinux or Docker Compose stop, because the web UI is identical once you reach the login screen. I went through and tested every step again on Graylog 7.2.2 and Ubuntu 24.04 in November 2026, and every screen, timing and error below comes from that lab box.

How logs move through the Graylog 7 lab: Linux hosts, Applications and You to graylog-server over UDP 514, UDP 12201 and HTTP 9000; graylog-server to Graylog Data Node over index; graylog-server to MongoDB over 27017

Each section below works on one of those arrows, in the order you’ll meet them.

Get past the preflight login

The lab set http_bind_address = 0.0.0.0:9000 in server.conf so the browser could reach port 9000 directly. If your install keeps the default 127.0.0.1:9000 behind nginx, use your nginx HTTPS address wherever this tour says port 9000. The first time Graylog starts, that address doesn’t serve the normal login page. It serves a preflight wizard behind a browser password prompt, and that prompt wants a temporary password Graylog printed in its log, not the admin password you hashed into server.conf. Pull it out of the server log:

sudo grep "Initial configuration is accessible" /var/log/graylog-server/server.log | tail -1

You’ll get one line with the username and the generated password:

Initial configuration is accessible at 0.0.0.0:9000, with username 'admin' and password 'VhWRbFOaHA'.

That password survived two service restarts in the lab, so you do not have to rush, and you can come back to it if the browser prompt times out on you. The banner around it also suggests a http://admin:password@host:9000 link, which saves you typing the password into the prompt at all. You’ll see the same lookup in this capture from the lab box.

Graylog 7.2 server.log line with the temporary preflight username and password

Once you’re in, the wizard lists every data node that has registered and walks you through four steps. On a single node you can accept the defaults on each one:

  1. You click Create CA and keep the suggested organization name, Graylog CA.
  2. You leave the Renewal Policy on Automatic with a 30 day Certificate lifetime and click Create policy.
  3. You click Provision certificate and continue and wait while the data node restarts with TLS.
  4. You click Resume startup once all four steps show a green check.

Automatic renewal is the right call for a lab and for most small installs, because a manual policy only raises a notification near expiry and then waits for someone to confirm it. If nobody does, the data node certificates lapse and search stops working, so you’d be debugging a TLS error a month from now instead of reading logs. Leave both fields as they are on the renewal step.

Graylog 7.2 preflight wizard renewal policy step with Automatic renewal and a 30 day certificate lifetime
  1. 1Renewal Policy
  2. 2Certificate lifetime
  3. 3Create policy

The provisioning step is the slow one, because the data node has to restart OpenSearch with its new certificate before Graylog can talk to it. It took 95 seconds on a 4 vCPU, 16 GB VM, and the page sits on a spinner the whole time, which is normal, so don’t refresh it halfway. When it finishes, every step turns green and the Resume startup button appears.

Graylog 7.2 preflight wizard with every step complete and the Resume startup button

After the click, Graylog answered its health check 17 seconds later and swapped the wizard for the real login page. The preflight only runs on a fresh install, so from now on port 9000 opens the normal login. The “Waiting for Graylog server” page refreshes itself once the server answers, and it says you can reload it by hand at any time, so you lose nothing by pressing F5.

“MongoDB cannot start: Linux kernel versions 6.19 and newer”

If the wizard never shows up and graylog-server keeps logging connection timeouts, check mongod first. On my Ubuntu 24.04 cloud image, which boots a 7.0 kernel, MongoDB 8.0.34 refused to start at all, and the journal said why. The 8.0 builds exit on purpose because of a known crash with kernels 6.19 and newer. This capture shows the fatal line from that first 8.0 attempt, with the package versions after the lab’s first workaround, MongoDB 7.0.45, which is explained below.

The fatal MongoDB cannot start line from the first mongod 8.0 attempt on kernel 7.0, with the package versions after the fix

Graylog 7.2 supports MongoDB 7.x through 8.2.x, so on a fresh install the clean fix is the 8.2 line, which our Ubuntu and Debian install guide also uses. If you followed that guide you’re already on 8.2 and can skip this. Graylog’s own Ubuntu steps install from the 8.0 repository and hold mongodb-org, so the block lifts the hold first, otherwise apt-get install -y aborts on the held package. The 8.2 repository is signed with the same 8.0 key you already imported. Run the swap as one block:

sudo apt-mark unhold mongodb-org
sudo rm -f /etc/apt/sources.list.d/mongodb-org-8.0.list
echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-8.0.gpg ] https://repo.mongodb.org/apt/ubuntu noble/mongodb-org/8.2 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-8.2.list
sudo apt-get update
sudo apt-get install -y mongodb-org
sudo apt-mark hold mongodb-org
sudo systemctl restart mongod

Starting from a held, never-started 8.0.34, that block installed 8.2.12, and mongod was still active on the 7.0 kernel 90 seconds later. Stick to a current 8.2 build, because early 8.2 releases were reported to crash-loop on 6.19 kernels too. Only do this on a fresh install: 8.0 never started here, so /var/lib/mongodb held no data to migrate.

Then restart Graylog so it reconnects. On a single-host install like this lab, both services live on the same box:

sudo systemctl restart graylog-datanode graylog-server

On a split layout, restart graylog-datanode on its own host instead. The rest of this tour first ran on MongoDB 7.0.45 (the 22.04 build from MongoDB’s jammy repository, which has no kernel check), and the 8.2 route above was verified on the same VM afterwards. In both cases the preflight banner appeared in the Graylog log within a minute of the restart, so you can go straight back to the wizard.

Sign in with your own admin password

The part that trips people up is which password the new login page wants. It’s the one whose SHA-256 hash sits in root_password_sha2 in /etc/graylog/server/server.conf, with the username admin. The preflight password is dead the moment you click Resume startup, so if you still have it on your clipboard, the login page turns it away. The lab login did exactly that.

Graylog 7.2 login page showing Invalid credentials after trying the preflight password

Type admin and your own password instead, and the welcome page loads.

“Invalid credentials, please verify them and retry”

If your own password is also rejected, the hash in server.conf does not match what you’re typing. A common cause is hashing with a trailing newline, which echo adds unless you pass -n, so the hash is valid but belongs to a slightly different string. Generate a fresh one, and type the password exactly as you’ll type it at the login page.

echo -n "YourPassword" | sha256sum | cut -d" " -f1

Paste the 64-character result into root_password_sha2, then restart the server so it reads the new value:

sudo systemctl restart graylog-server

The first successful login also opens an anonymous usage data prompt. Click Cancel if you’d rather not send telemetry, and you can change your mind later in your user profile. Neither choice affects anything else in this tour, so pick whichever your policy prefers.

Find your way around the top navigation

Everything in Graylog hangs off one top bar, and you’ll spend most of your time in Search and the System menu. The welcome page in 7.2 adds two shortcuts under “Where would you like to start?”: enrolling the new Graylog Collector agent, which is still marked Preview, and Configure Input, which takes you straight to the inputs page. You can ignore the Collector card for now, because an input is all you need to start receiving syslog.

Graylog 7.2 welcome page with the top navigation bar and the Configure Input shortcut
  1. 1Search
  2. 2System
  3. 3Configure Input

Each menu does one job, and two of them are mostly sales pages on an open source install. This table shows what you’ll find behind each one, so you know where not to look for your logs.

MenuWhat you use it for
SearchQuery messages with a time range, histogram and message table
StreamsRoute messages into named buckets, each tied to an index set
AlertsAlerts and Events, Event Definitions and Notifications
DashboardsSaved widget pages, including a built-in Sources dashboard
EnterpriseCluster ID and the status of licensed Enterprise modules
SecurityOverview, User Activity, Host Activity, Network Activity and Anomalies pages that preview the paid Graylog Security edition
SystemOverview, Configurations, Cluster Configuration, Inputs, Outputs, Indices, Logging, Users and Teams, Roles, Authentication, Content Packs, Grok Patterns, Lookup Tables, Pipelines, Sidecars and Collectors

The bell beside System showed one urgent notification right after login: “There is a node without any running inputs”. That’s normal on a new install and clears on its own once you launch the input in the next section. The “0 in / 0 out” counter on the right is live throughput, and it’s the quickest way to see whether anything is arriving at all.

Launch your first input with the setup wizard

Inputs are the network listeners that receive logs, and nothing gets collected until at least one is running. Syslog UDP is the right first input, because every Linux box can already send to it with rsyslog and you don’t install anything on the clients. Go to System > Inputs, pick Syslog UDP from the Select input list and click Launch new input.

Graylog 7.2 System Inputs page with Syslog UDP selected and the Launch new input button
  1. 1System > Inputs
  2. 2Select input
  3. 3Launch new input

Give the input a Title such as “Linux Syslog UDP” and leave the Port on its default of 514. Older guides, including the earlier version of this one, moved syslog to 1514 because Graylog runs as a non-root user. The 7.2 packages don’t need that, because the graylog-server unit carries AmbientCapabilities=CAP_NET_BIND_SERVICE. The input bound to UDP 514 without any extra setup, so your clients can keep the standard port. That capability belongs to the deb and rpm systemd unit, though. The Docker Compose deployment publishes syslog on 5140, so set the input port to 5140 there and point your senders at 5140. Click Launch Input when the form looks like this.

Graylog 7.2 Launch new Syslog UDP input dialog with the title set and the default port 514
  1. 1Title
  2. 2Port
  3. 3Launch Input

This is where Graylog 7.2 differs from every older tour. The input is created in a Setup state, and a yellow banner warns that inputs in setup mode won’t receive messages. An Input Setup Wizard opens with Routing, Launch and Diagnosis steps, and you have to finish it, because a launched input that skips the wizard never leaves Setup. On the Routing step, click Create Stream (Graylog marks it as recommended) and then Next.

Graylog 7.2 Input Setup Wizard routing step offering Create Stream or Select Stream
  1. 1Create Stream
  2. 2Next

Name the stream “Linux Servers” in the Title field and keep Remove matches from Default Stream ticked, so these messages don’t land twice. The wizard warns against the Default Index Set because mixed message formats can hit the search backend’s field limit per index. That’s sound advice for production, though one syslog input in a lab is fine on the default set, and you can move the stream to its own index set later.

Graylog 7.2 Input Setup Wizard creating the Linux Servers stream on the default index set
  1. 1Title
  2. 2Remove matches from Default Stream

Click Next, then Start Input on the Launch step. The wizard creates and starts the stream, creates a pipeline with the same name, wires up the routing and starts the input, and each step gets its own green check.

Graylog 7.2 Input Setup Wizard confirming the Linux Servers stream, pipeline and routing were created and the input started

If you close the wizard early, the input stays in Setup and silently drops everything sent to it, which looks exactly like a firewall problem from the client side. You can reopen the wizard from the yellow Set-up Input button on the input’s row. When ufw is active on Ubuntu, open the ports you’ll use before any client sends traffic. Limit them to the network your log sources live on, because anyone who can reach UDP 514 can inject fake log lines, and port 9000 serves the admin login over plain HTTP. Replace 10.0.1.0/24 with your own subnet.

sudo ufw allow from 10.0.1.0/24 to any port 514 proto udp comment "Graylog Syslog UDP"
sudo ufw allow from 10.0.1.0/24 to any port 12201 proto udp comment "Graylog GELF UDP"
sudo ufw allow from 10.0.1.0/24 to any port 9000 proto tcp comment "Graylog web UI"

Rocky Linux and AlmaLinux use firewalld instead, and the Rocky and AlmaLinux install guide has those rules.

Create an input from the REST API

Scripted setups can skip the dialog and post the input as JSON, which is handy when you rebuild Graylog often or manage it with Ansible. Put the admin password in a variable first, so it doesn’t sit in every command you paste.

export GL_PASS='YourPassword'

Next, create the input definition in a file called gelf-input.json.

sudo vim gelf-input.json

Add the GELF UDP input type, the port and the receive buffer.

{
  "title": "GELF UDP",
  "type": "org.graylog2.inputs.gelf.udp.GELFUDPInput",
  "global": true,
  "configuration": {
    "bind_address": "0.0.0.0",
    "port": 12201,
    "recv_buffer_size": 262144
  }
}

Post it to the API. The X-Requested-By header is mandatory on every write, and leaving it out is the first error most people hit.

curl -s -u admin:"$GL_PASS" -X POST http://127.0.0.1:9000/api/system/inputs -H "Content-Type: application/json" -H "X-Requested-By: cli" -d @gelf-input.json; echo

Without the header you’ll see “CSRF protection header is missing”, and with it you get back the new input’s ID. Both answers are in this capture, followed by the input states.

Creating a Graylog GELF UDP input with curl, first rejected for a missing X-Requested-By header, then accepted

Unlike the dialog, the API path doesn’t trigger the setup wizard. The GELF input went straight to RUNNING with no stream of its own, so its messages land in the Default Stream. That’s fine for testing, but you’ll want to route it to its own stream before real applications point at it, because the Default Stream is where unrouted messages pile up.

Send test logs with rsyslog and GELF

Real system logs make the rest of the tour easier to follow, and rsyslog can forward them in one line. The rule below sends everything to UDP 514 in RFC 5424 format, which the syslog input parses cleanly. On the Graylog server itself 127.0.0.1 works, and on other machines you use the Graylog server’s IP, for example 10.0.1.50.

echo "*.* @127.0.0.1:514;RSYSLOG_SyslogProtocol23Format" | sudo tee /etc/rsyslog.d/60-graylog.conf

A single @ means UDP and @@ means TCP. Validate the config before restarting, so a typo doesn’t stop local logging too:

sudo rsyslogd -N1

You should see two lines and no error, with the second one saying “End of config validation run”.

rsyslogd: version 8.2312.0, config validation run (level 1), master config /etc/rsyslog.conf
rsyslogd: End of config validation run. Bye.

Restart rsyslog and write a test line, which showed up in Search within seconds.

sudo systemctl restart rsyslog
logger -t lab-test "Test message from rsyslog to Graylog"

If you’re running a separate collector already, the rsyslog centralized log server guide shows how to relay from that box into Graylog. GELF is the better fit for application logs because it carries custom fields. These four messages give the search section something to filter on, and nc sends each one as a single UDP datagram to the GELF input you created through the API.

echo -n '{"version":"1.1","host":"web01","short_message":"Deployment complete","level":6,"_environment":"staging","_app":"myapp","_deploy_id":"d-4521"}' | nc -u -w1 127.0.0.1 12201
echo -n '{"version":"1.1","host":"db01","short_message":"Replication lag exceeded 5s","level":4,"_environment":"production","_app":"postgres","_lag_seconds":5.2}' | nc -u -w1 127.0.0.1 12201
echo -n '{"version":"1.1","host":"web01","short_message":"Health check passed","level":6,"_environment":"production","_app":"nginx","_response_time_ms":12}' | nc -u -w1 127.0.0.1 12201
echo -n '{"version":"1.1","host":"app03","short_message":"OutOfMemoryError in worker thread","level":3,"_environment":"production","_app":"java-api","_heap_used_mb":3891}' | nc -u -w1 127.0.0.1 12201

The level values follow syslog severity, so 3 is error, 4 is warning and 6 is informational. Keep that in mind, because the alert later in this tour keys off it. GELF over UDP sends nothing back, so nc exits quietly whether or not Graylog took the message, and the search page is where you find out.

Search messages and read the results

Search is where Graylog earns its keep. Set the Time range preset to 1 hour, because the default 5 minutes hides anything older and is the usual reason a fresh search comes back empty. Type a query into the Search query box and press Enter, or click Perform Search.

Graylog 7.2 Search page filtering GELF messages with environment:production over the last hour
  1. 1Time range preset
  2. 2Search query
  3. 3Perform Search

The header reports how long the query took and how many messages matched, 15 ms and 3 results here. Each of these queries returned the expected messages in the lab, so you can paste them as a starting point.

QueryWhat it found
environment:productionThe 3 GELF messages tagged production
app:java-apiThe OutOfMemoryError from app03
environment:production AND level:<=4Warnings and worse in production (2 hits)
response_time_ms:>5Numeric range on a GELF field
source:graylog01Everything rsyslog forwarded from the server itself
level:3Every error-level message
NOT level:6Everything except informational messages

Range queries like level:<=4 and response_time_ms:>5 work because both values arrived as JSON numbers, so Graylog can compare them instead of matching text. Start with a field query like these whenever you can, because they were also the fastest searches in the timing test below.

Searching _app returns nothing

You send GELF custom fields with a leading underscore, but Graylog stores them without it. So _app:java-api finds nothing and app:java-api finds the message. The earlier version of this guide had this wrong in its query table, and the API shows the difference plainly.

Graylog search API returning 0 results for _app:java-api and 1 result for app:java-api

The same rule applies to alert queries, stream rules and dashboard filters, so drop the underscore everywhere you reference a GELF field inside Graylog. You only keep it in the JSON you send.

How fast search was on 491,000 messages

After the ingest test later in this tour, the index held 491,332 messages from the past hour. Each query ran three times through the search API, and the script kept the average and the worst run.

Graylog 7.2 search query timings over 491,332 messages from the lab, from 12 ms to 198 ms

Field queries finished in 12 to 42 ms, a negation took 73 ms and a bare * over the whole hour took 191 ms. A wide match-everything query is the costly one, so keeping the time range tight matters more than how you write the query. On a single data node with 16 GB of RAM, none of these got near the point where you’d wait for results, which means slow searches on a small install usually point at a huge time range rather than a weak server.

Check streams and index sets

Open Streams and you’ll see the “Linux Servers” stream next to the built-in Default Stream, All events and All system events. The wizard already filled in its index set and its pipeline, so you have nothing to configure here for the first stream.

Graylog 7.2 Streams page with the Linux Servers stream created by the input setup wizard

Each stream writes to an index set under System > Indices, and that’s where retention lives. The defaults on a fresh 7.2 install aren’t the “1 GB or 1 day, 20 indices” figures older guides quote, so don’t plan disk space from those. The API reported these values for the Default index set.

  • You get a time-based, size-optimizing rotation, so Graylog decides when to start a new index.
  • You keep data for at least 30 and at most 40 days, after which Graylog deletes it, however many indices that takes.
  • You run 1 shard and 0 replicas, which suits a single data node.

Create a separate index set when one source needs different retention, such as security logs kept for 90 days next to debug logs you’d drop after a few. The API still reports a max_number_of_indices of 20, but this rotation strategy retains by lifetime and ignores that count. Plan disk as daily volume times up to 40 days, so a noisy source on the default set can fill a small data node well before any old data expires. These Linux log management practices help you size that retention.

Build a dashboard widget

Dashboards start empty. Go to Dashboards, create a new one, open the Create section in the left sidebar and pick a widget. Message Count under Predefined Aggregation is the one-click option, so it’s the quickest way for you to see how dashboards behave.

Graylog 7.2 new dashboard with the Create sidebar listing widget types including Message Count
  1. 1Create
  2. 2Message Count

The widget opens in edit mode. Click Update widget, then Save as, because the plain Save button stays greyed out on a dashboard that has never been saved. Give it a title and click Create dashboard. The lab one is called “Lab Overview”.

Graylog 7.2 Lab Overview dashboard with a Message Count widget showing 49 messages in the last 5 minutes

Don’t expect a histogram here. In 7.2 the Message Count widget is a single number, and it kept its own “5 minutes ago to Now” range even though the dashboard was set to 1 hour before the widget was added. That catches people out, because the number looks far too low until you read the small range under it. Build an Aggregation widget grouped by timestamp when you want a chart over time.

Create an alert that fires on errors

Alerts start as event definitions. Go to Alerts > Event Definitions, click Create event definition, give it a title such as “Error burst on Linux Servers” and set the priority. On the next step choose the Filter & Aggregation condition type and fill in the filter.

Graylog 7.2 event definition filter matching level 3 or lower on the Linux Servers stream every minute
  1. 1Search Query
  2. 2Streams and Categories
  3. 3Execute search every

These are the values the lab used, and you can check each one off as you fill it in.

  • You set the Search Query to level:<=3 so it matches error, critical, alert and emergency messages.
  • You pick “Linux Servers” in Streams and Categories so the search skips the GELF test data.
  • You set both “Search within the last” and Execute search every to 1 minute so nothing falls between runs.
  • You leave “Filter has results” selected and click through to Create event definition on the Summary step.

To test it, send a few error-level syslog lines from the server. They travel through rsyslog and the Linux Servers stream, so you’re testing the whole path, not just the alert.

for i in 1 2 3; do logger -p user.err -t payment-api "Upstream timeout talking to db01 (attempt $i)"; done

Each run of that loop created three events under Alerts & Events within a minute, one per matching message, all marked High. The list below holds two test runs, so you see more than three rows.

Graylog 7.2 Alerts and Events page listing Error burst on Linux Servers events with priority High

Look at the Type column: these are Events, not Alerts. The events API returned "alert": false for all of them, because Graylog only promotes an event to an alert when the definition has a notification attached. Create one under Alerts > Notifications, then attach it on the Notifications step of the definition. Until you do, nothing leaves the Graylog UI.

Measure UDP ingest before you trust it

UDP inputs drop messages without telling you when the socket buffer fills, and the default buffer fills sooner than you’d guess. To measure it, a Python script on the same VM fired RFC 5424 messages at the syslog input at fixed rates, and the search API then counted what Graylog stored.

Send rateSentStoredLostInput receive buffer
1,000/s30,00030,0000262,144 (default)
5,000/s60,00060,0000262,144 (default)
10,000/s100,00099,292708262,144 (default)
83,577/s burst100,00044,55355,447262,144 (default)
10,000/s100,000100,00004,194,304
20,000/s100,000100,00004,194,304
90,086/s burst100,00057,18042,8204,194,304

Every lost message matched the kernel’s UdpRcvbufErrors counter exactly, so the drops happened in the socket buffer before Graylog saw anything. The journal API showed no uncommitted entries after the runs. Raising the input’s receive buffer to 4 MB made 10,000 and 20,000 messages a second lossless. Nothing makes an unpaced burst safe over UDP, though, so switch busy senders to TCP or GELF TCP. Check the drop counter and the kernel ceiling on your own server.

sysctl net.core.rmem_max net.core.rmem_default
nstat -az UdpRcvbufErrors
sudo ss -ulpnm sport = :514

In the skmem line, rb is the buffer the socket actually got. It read 8388608 after the input asked for 4 MB, because the kernel doubles the requested size for its own bookkeeping. The UdpRcvbufErrors total includes every test run, so watch whether it grows rather than what it reads.

Checking net.core.rmem_max, UdpRcvbufErrors and the Graylog syslog socket buffer size on Ubuntu 24.04

The kernel caps any requested buffer at net.core.rmem_max. The lab’s cloud image already allowed 4 MB, but if yours reads 212992, raise it with a sysctl drop-in.

echo "net.core.rmem_max=8388608" | sudo tee /etc/sysctl.d/90-graylog-udp.conf
sudo sysctl --system | grep rmem_max

Then open the input’s More menu on System > Inputs, choose Edit input and set Receive Buffer Size to 4194304. The lab made the same change through the API’s input update call, and the input came back RUNNING with the new buffer size within seconds. Run the nstat check again after your next busy period to confirm the counter stopped growing.

Verify the data path from the API

Older guides check message totals with /api/count/total, but that endpoint returns 404 on 7.2. The search API gives you the total instead, and the indexer health endpoint tells you whether OpenSearch on the data node is happy.

curl -s -u admin:"$GL_PASS" -H "Accept: application/json" "http://127.0.0.1:9000/api/search/universal/relative?query=*&range=3600&limit=1" | jq "{total_results, took_ms: .time}"
curl -s -u admin:"$GL_PASS" -H "Accept: application/json" http://127.0.0.1:9000/api/system/indexer/cluster/health | jq

A green status with zero unassigned shards means indexing works end to end. This run was taken just before the ingest test, when 55 messages had arrived.

Graylog 7.2 API checks: /api/count/total returns 404, the search API returns totals and the indexer cluster is green

The same health shows in the web UI under System > Cluster Configuration, with JVM heap, buffer and journal use for each Graylog node. Journal use climbing here means Graylog receives faster than it can index.

Graylog 7.2 Cluster Configuration page with a green OpenSearch cluster and the graylog01 node running

If the count stays at zero, start with the input state, because an input stuck in Setup drops everything without an error. Next, widen the time range, then confirm the firewall allows the port. Last, check that the sender points at the right IP and port, since UDP senders never report a wrong address.

Take the lab setup toward production

The lab above ran over plain HTTP on port 9000 with one admin account, which is fine for a test box and not much more. Before real users and real logs arrive, you should be able to tick off each of these.

  • You’ve put the web UI behind TLS, and the Nginx reverse proxy with Let’s Encrypt guide walks through it.
  • You’ve given each person their own account under System > Users and Teams or connected LDAP under Authentication.
  • You’ve moved busy senders off UDP, or sized the receive buffer as shown above.
  • You’ve attached a notification to every event definition that should wake someone up.
  • You back up MongoDB, because it holds every stream, dashboard, user and input, and losing it means rebuilding all of that by hand.

The Graylog web interface documentation covers the remaining settings, and keeping the journal on persistent storage pairs well with persistent systemd journal storage on the hosts you collect from.

Keep reading

How to Upgrade Fedora 44 to Fedora 45 (GUI, CLI and Rollback) Fedora How to Upgrade Fedora 44 to Fedora 45 (GUI, CLI and Rollback) Upgrade Ubuntu 24.04 to Ubuntu 26.04 LTS (Step by Step) Ubuntu Upgrade Ubuntu 24.04 to Ubuntu 26.04 LTS (Step by Step) UFW Firewall Commands with Examples on Ubuntu 26.04 / 24.04 Security UFW Firewall Commands with Examples on Ubuntu 26.04 / 24.04 Git CVE-2026-111760: Check and Patch the Recursive Clone RCE Git Git CVE-2026-111760: Check and Patch the Recursive Clone RCE Deploy Collabora Online Office on Ubuntu with Let’s Encrypt SSL Cloud Deploy Collabora Online Office on Ubuntu with Let’s Encrypt SSL Databases Install Apache, MariaDB, and PHP (LAMP) on Void Linux

Leave a Comment

Press ESC to close