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.
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.

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.

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:
- You click Create CA and keep the suggested organization name, Graylog CA.
- You leave the Renewal Policy on Automatic with a 30 day Certificate lifetime and click Create policy.
- You click Provision certificate and continue and wait while the data node restarts with TLS.
- 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.

- 1Renewal Policy
- 2Certificate lifetime
- 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.

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.

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.

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.

- 1Search
- 2System
- 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.
| Menu | What you use it for |
|---|---|
| Search | Query messages with a time range, histogram and message table |
| Streams | Route messages into named buckets, each tied to an index set |
| Alerts | Alerts and Events, Event Definitions and Notifications |
| Dashboards | Saved widget pages, including a built-in Sources dashboard |
| Enterprise | Cluster ID and the status of licensed Enterprise modules |
| Security | Overview, User Activity, Host Activity, Network Activity and Anomalies pages that preview the paid Graylog Security edition |
| System | Overview, 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.

- 1System > Inputs
- 2Select input
- 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.

- 1Title
- 2Port
- 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.

- 1Create Stream
- 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.

- 1Title
- 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.

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.

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.

- 1Time range preset
- 2Search query
- 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.
| Query | What it found |
|---|---|
environment:production | The 3 GELF messages tagged production |
app:java-api | The OutOfMemoryError from app03 |
environment:production AND level:<=4 | Warnings and worse in production (2 hits) |
response_time_ms:>5 | Numeric range on a GELF field |
source:graylog01 | Everything rsyslog forwarded from the server itself |
level:3 | Every error-level message |
NOT level:6 | Everything 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.

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.

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.

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.

- 1Create
- 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”.

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.

- 1Search Query
- 2Streams and Categories
- 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:<=3so 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.

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 rate | Sent | Stored | Lost | Input receive buffer |
|---|---|---|---|---|
| 1,000/s | 30,000 | 30,000 | 0 | 262,144 (default) |
| 5,000/s | 60,000 | 60,000 | 0 | 262,144 (default) |
| 10,000/s | 100,000 | 99,292 | 708 | 262,144 (default) |
| 83,577/s burst | 100,000 | 44,553 | 55,447 | 262,144 (default) |
| 10,000/s | 100,000 | 100,000 | 0 | 4,194,304 |
| 20,000/s | 100,000 | 100,000 | 0 | 4,194,304 |
| 90,086/s burst | 100,000 | 57,180 | 42,820 | 4,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.

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.

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.

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.