Forem: The Astronomer

I just discovered that I have many followers on here. How many of you are real? Please comment.

The Astronomer — Mon, 26 Jan 2026 02:59:58 +0000

I just logged in after a long time and I see so many followers. But are you all real?

Monitoring Docker Containers with Datadog on Ubuntu

The Astronomer — Sat, 17 Aug 2024 00:25:48 +0000

I just started monitoring my docker containers running on Ubuntu server. Just in case it helps someone else too, I wanted to share the steps I followed. I will try to walk you through the process of setting up Datadog to monitor your Docker containers on an Ubuntu server, from signing up for a free trial to configuring the Datadog Agent.

1. Sign Up for a Datadog Free Trial

Find Datadog Website: Google the link to sign up for free trial and visit the page.
Sign Up: Click on "Start Free Trial" and fill out the registration form. Follow the prompts to create your brand new account.
Install Agent: After you are signed up, Datadog will provide you with an installation command specific to your account. This command is used to install the Datadog Agent on your Ubuntu server.

2. Install the Datadog Agent on Ubuntu

Run the Installation Command: Datadog will give you a list of options to get installation steps for different kinds of machines. Since we are doing this on Ubuntu machine, choose Ubuntu from the list. There it shows the command that we need. It also has the API Key in it. Copy and paste the installation command provided by Datadog into your terminal where you are logged on to your ubuntu server.
Verify Installation: After running the command, the Datadog Agent should be installed on your server. You can verify this by checking the service status:

   sudo systemctl status datadog-agent

3. Configure Datadog to Monitor Docker Containers

Fun starts now. Datadog should take you to the integration page where you can select and install Docker. Go back to the terminal for now and do step 1 first:

Add dd-agent User to Docker Group: To allow the Datadog Agent to communicate with Docker, you need to add the dd-agent user to the Docker group. Run:

   sudo usermod -a -G docker dd-agent

After running this command, you may need to log out and log back in for the group changes to take effect. I didn't have to do that.

Enable Docker Integration in Datadog:
- Back to Datadog website: Go to the Datadog Integrations page.
- Search for docker if not already shown to you: Locate the Docker integration and click "Install". Btw, this will also show you the steps there but I found it really confusing (like I didn't really know where this conf.d folder was located). Hence, I decided to write this article as it might be helpful for others.

Configure Docker Integration:
- Edit Configuration File: Open the configuration file for Docker integration. If you go to /etc/datadog-agent/conf.d/docker.d/ on your machine, you may not see the yaml file there. This command will create a new one for you.:
```
 sudo nano /etc/datadog-agent/conf.d/docker.d/docker_daemon.yaml
```

Add Configuration:
Add the following configuration to the file:
```
 init_config:

 instances:
     - url: "unix://var/run/docker.sock"
```
This configuration sets the Datadog Agent to connect to the Docker daemon via the Docker socket.
Save and Exit: In nano, save changes by pressing CTRL + O, then Enter, and exit with CTRL + X. If you have never used nano before, you can find how to use it by quick Googling. You just need 1 or 2 commands for this though. No need to learn everything.

Restart the Datadog Agent:
To apply the changes, restart the Datadog Agent service:
- Stop the Agent: Stop command:
```
 sudo systemctl stop datadog-agent
```

Start the Agent:
To start the Datadog Agent again, use:
```
 sudo systemctl start datadog-agent
```

Verify Integration:
Check the status of the Datadog Agent to ensure that the Docker integration is working correctly:
```
  sudo datadog-agent status
```

Look for the docker section under Checks to confirm that Docker monitoring is active. Then just go to the dashboard on Datadog website to see the metrics.

Conclusion

By following these steps, you can effectively monitor your Docker containers with Datadog on an Ubuntu server. This setup allows you to gain deep insights into your containerized applications. Now you can quickly respond to any performance issues or anomalies.

Building a Real-Time Chatroom with Spring Boot and WebSockets

The Astronomer — Fri, 16 Aug 2024 17:25:10 +0000

In this guide, we will walk through the steps to build a very simple real-time chatroom application using Spring Boot and WebSockets. We will use static HTML and CSS for the frontend. Usernames of users will be randomly generated allowing for anonymous chat.

Overview

Our chatroom application will allow users to join, send messages, and see messages from other users in real-time. We will use Spring Boot for the backend and WebSockets for real-time communication.

Prerequisites

Java 17 or higher
Maven

Project Structure

pom.xml: Maven configuration file with dependencies and plugins.
src/main/java/com/chatroom/demo: Contains the main application and configuration files.
- DemoChatroomApplication.java: Main class to run the Spring Boot application.
- config/WebSocketConfig.java: Configuration for WebSocket and STOMP.
- controller/ChatController.java: Controller to handle chat messages.
- model/ChatMessage.java: Model class representing a chat message.
src/main/resources/static: Contains static resources like HTML, CSS, and JavaScript files.
- index.html: Main HTML file for the chatroom UI.
- main.css: CSS file for styling the chatroom.
- app.js: JavaScript file for handling WebSocket connections and UI interactions.

Step-by-Step Guide

1. Set Up the Spring Boot Project

Create a new Spring Boot project using Spring Initializr or your preferred method. Add the following dependencies to your pom.xml:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-websocket</artifactId>
    </dependency>
</dependencies>

2. Create the Main Application Class

Your main application class DemoChatroomApplication.java should look like this:

package com.chatroom.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoChatroomApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoChatroomApplication.class, args);
    }
}

3. Configure WebSocket

The WebSocketConfig.java file is a configuration class for setting up WebSocket messaging and implements the WebSocketMessageBrokerConfigurer interface, which provides methods to configure the message broker and register STOMP (Simple Text Oriented Messaging Protocol) endpoints.

The class WebSocketConfig implements WebSocketMessageBrokerConfigurer, which requires the implementation of two methods: configureMessageBroker and registerStompEndpoints.

The configureMessageBroker method configures the message broker, which is responsible for routing messages from one client to another.

config.enableSimpleBroker("/topic") enables a simple in-memory message broker with a destination prefix /topic. This is where the server will send messages to clients.

config.setApplicationDestinationPrefixes("/app") Sets the application destination prefix to /app. This prefix is used to filter destinations targeted to application-specific message-handling methods.

The registerStompEndpoints method registers the STOMP endpoints, which clients will use to connect to the WebSocket server.

registry.addEndpoint("/ws").withSockJS() registers an endpoint at /ws and enables SockJS fallback options. SockJS is a library that provides WebSocket-like communication for browsers that don't support WebSocket.

For this class you'll need @Configuration and @EnableWebSocketMessageBroker annotations. @Configuration indicates that the class is a source of bean definitions and @EnableWebSocketMessageBroker enables WebSocket message handling, backed by a message broker.

WebSocketConfig.java:

package com.chatroom.demo.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        config.enableSimpleBroker("/topic");
        config.setApplicationDestinationPrefixes("/app");
    }

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws").withSockJS();
    }
}

4. Create the Chat Controller

Create a controller class ChatController.java:

package com.chatroom.demo.controller;

import com.chatroom.demo.model.ChatMessage;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Controller;

@Controller
public class ChatController {

    @MessageMapping("/chat")
    @SendTo("/topic/messages")
    public ChatMessage send(ChatMessage message) {
        return message;
    }
}

5. Create the Chat Message Model

Create a model class ChatMessage.java:

package com.chatroom.demo.model;

public class ChatMessage {
    private String content;
    private String username;
    // Getters and setters
    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }
}

6. Create the Frontend Files

In a Spring Boot application, static resources such as HTML, CSS, and JavaScript files are served automatically from the src/main/resources/static directory. This behavior is provided by Spring Boot's default configuration.

How It Works
Default Resource Mapping: Spring Boot automatically maps resources from the src/main/resources/static directory to the root path (/). This means that any file placed in the static directory can be accessed directly via the web browser.

Serving HTML: When you place an index.html file in the static directory, it will be served as the default page when you navigate to the root URL (http://localhost:8080).

Use React: You can also use React to build your frontend if you'd like. All you'd have to do is build your React app and place the build files in the Spring Boot static directory. Then run the Spring Boot application to serve the React frontend.

Create the following files in src/main/resources/static:

index.html

<!DOCTYPE html>
<html>
<head>
    <title>Demo Chatroom</title>
    <link rel="stylesheet" type="text/css" href="main.css">
</head>
<body>
    <div id="chatroom">
        <h1>Chatroom</h1>
        <div id="messages"></div>
        <input type="text" id="message-input" placeholder="Type a message...">
        <button onclick="sendMessage()">Send</button>
    </div>
    <script src="https://cdn.jsdelivr.net/npm/sockjs-client@1.5.1/dist/sockjs.min.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/stompjs@2.3.3/lib/stomp.min.js"></script>
    <script src="app.js"></script>
</body>
</html>

main.css

#chatroom {
    width: 50%;
    margin: auto;
    text-align: center;
}

#messages {
    border: 1px solid #ccc;
    height: 300px;
    overflow-y: scroll;
    margin-bottom: 10px;
}

#message-input {
    width: 80%;
    padding: 10px;
}

button {
    padding: 10px;
}

app.js

var stompClient = null;

var username = generateRandomUsername();

function generateRandomUsername() {
    var adjectives = ["Quick", "Lazy", "Happy", "Sad", "Angry"];
    var nouns = ["Fox", "Dog", "Cat", "Mouse", "Bear"];
    var adjective = adjectives[Math.floor(Math.random() * adjectives.length)];
    var noun = nouns[Math.floor(Math.random() * nouns.length)];
    return adjective + noun + Math.floor(Math.random() * 1000);
}

function connect() {
    var socket = new SockJS('/ws');
    stompClient = Stomp.over(socket);
    stompClient.connect({}, function (frame) {
        console.log('Connected: ' + frame);
        stompClient.subscribe('/topic/messages', function (message) {
            showMessage(JSON.parse(message.body));
        });
    });
}

function sendMessage() {
    var messageContent = document.getElementById('message-input').value;
    stompClient.send("/app/chat", {}, JSON.stringify({'username': username, 'content': messageContent}));
    document.getElementById('message-input').value = '';
}

function showMessage(message) {
    var messagesDiv = document.getElementById('messages');
    var messageElement = document.createElement('div');
    messageElement.appendChild(document.createTextNode(message.username + ": " + message.content));
    messagesDiv.appendChild(messageElement);
}

connect();

Run the Application Build and run the Spring Boot application:

mvn clean install
mvn spring-boot:run

Open a web browser and navigate to http://localhost:8080 to access the chatroom.

Conclusion
You have successfully built a real-time chatroom application using Spring Boot and WebSockets with static HTML and CSS for the frontend. In future guides, we will enhance the frontend using modern frameworks like React.

A slightly more built-out version can be found here.

Setting Up Cloudflare with DigitalOcean: A Step-by-Step Guide (2024)

The Astronomer — Thu, 01 Aug 2024 03:14:15 +0000

So, I was trying to set up Cloudflare with DigitalOcean, and man, it was a real headache. I scoured the web for some up-to-date info, but all I found were old articles and videos that might not even be relevant anymore. My setup just wasn't working, and DigitalOcean didn't have any articles that matched what I was trying to do.

I think the issue might have been with the DigitalOcean image I was using for the droplet. So, I decided to start fresh and created a new droplet with Ubuntu 24.04 (LTS) x64 image. I followed these steps, and boom, everything worked like a charm! And yes, I am using websockets in my app (You'll see in the configuration below).

Step 1: Add Domain to Cloudflare

1.1. Sign Up/Log In to Cloudflare:

Go to the Cloudflare website and sign up or log in to your account.

1.2. Add Your Domain to Cloudflare:

In the Cloudflare dashboard follow the steps to add your domain. Start with the free plan. And allow Cloudflare to import DNS records if it asks.
- Edit DNS to point to your DigitalOcean droplet:
Add an A record to point your domain to the public IP address of your DigitalOcean droplet:
- Name: @ (for root domain) or www (for subdomain).
- IPv4 address: Your Droplet’s IP address.
- TTL: Auto.
Optionally, add a CNAME record to handle www subdomain redirection:
- Name: www
- Target: yourdomain.com

1.3. Update Nameservers:

Cloudflare will provide you with two nameservers. Log in to your Domain Registrar (like Namecheap) account and update the nameservers with the Cloudflare nameservers. It may take some time for the nameserver changes to propagate. Once Cloudflare tells you that your domain is ready, you can follow the following steps.

2. Set up SSL/TLS

3.1. Set Up SSL/TLS on Cloudflare:

Navigate to the SSL/TLS tab in Cloudflare.
Choose the appropriate SSL mode (e.g., Full, Full (strict), Flexible). It’s recommended to use "Full (strict)" for the best security, assuming you have SSL configured on your Droplet.

3.2. Generate a Cloudflare Origin Certificate

Log in to Cloudflare and select your domain.
Navigate to SSL/TLS > Origin Server.
Click Create Certificate.
Choose Let Cloudflare generate a private key and a CSR. This option will generate both a certificate and a private key.
Select the Key Format (PEM).
Add hostnames for which the certificate should be valid (e.g., yourdomain.com and *.yourdomain.com).
Click Next and Download both the certificate and the private key.

4. Install the Origin Certificate on Your Server

4.1. Save the Certificate and Private Key

Save the downloaded certificate and private key on your server. For example, you might save them in /etc/ssl/certs/ and /etc/ssl/private/, respectively:

sudo mkdir -p /etc/ssl/certs
sudo mkdir -p /etc/ssl/private

sudo nano /etc/ssl/certs/cloudflare_origin_cert.pem
# Paste the certificate content and save the file.

sudo nano /etc/ssl/private/cloudflare_origin_key.pem
# Paste the private key content and save the file.

4.2. Set Permissions

Set these permissions to the key files:

sudo chmod 600 /etc/ssl/private/cloudflare_origin_key.pem
sudo chown root:root /etc/ssl/private/cloudflare_origin_key.pem

5. Configure Nginx to Use the Origin Certificate

Make sure your Nginx configuration has these lines:

ssl_certificate /etc/ssl/certs/cloudflare_origin_cert.pem;
    ssl_certificate_key /etc/ssl/private/cloudflare_origin_key.pem;

Edit your Nginx server block configuration (usually located in /etc/nginx/sites-available/yourdomain.com).

If you don't already have Nginx installed. Follow these steps:

Install Nginx on your DigitalOcean droplet:
```
 sudo apt update
 sudo apt install nginx
```
- Configure Nginx to reverse proxy to your app running on port 8000 inside the droplet:
  - Create a new Nginx configuration file:
```
   sudo nano /etc/nginx/sites-available/yourdomain.com
```

Your Nginx configuration should look like this (Note that the WebSocket configuration in the Nginx setup is optional and should only be included if needed):

server {
    listen 80;
    server_name yourdomain.com www.yourdomain.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name yourdomain.com www.yourdomain.com;

    ssl_certificate /etc/ssl/certs/cloudflare_origin_cert.pem;
    ssl_certificate_key /etc/ssl/private/cloudflare_origin_key.pem;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    location /ws/ {
        proxy_pass http://127.0.0.1:8000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

6. Test and Restart Nginx

6.1. Check the Nginx configuration for syntax errors:

sudo nginx -t

6.2. If the test is successful, you can go ahead and restart Nginx to apply the changes:

    sudo systemctl restart nginx

7. Ensure Cloudflare SSL/TLS settings are correct

Log in to Cloudflare and select your domain.
Navigate to SSL/TLS > Overview.
Ensure the SSL/TLS encryption mode is set to Full or Full (strict).

8. Test

You should now try to visit your domain in a web browser. Your app that was running inside the VPS should now be accessible to the world.

Quote of the day

The Astronomer — Tue, 06 Sep 2022 00:56:14 +0000

Found in a comment of an article titled, "Getters/Setters. Evil. Period."