Designing Directory Structure for the MoolMeow Project 🏗️

Hello everyone! Today I’d like to share how I designed the directory structure for my MoolMeow project. 🐱 I’ll explain in detail how I configured the file system and mounted it to VMs in an on-premises Kubernetes environment!

Initial Consideration: How to Structure the Directories? 🤔

The MoolMeow project is an integrated community service themed around swimming (Mool, 물) and cats (Meow, 야옹). I’m planning to run it on Kubernetes using a Mac Mini, and I realized that establishing a systematic directory structure from the beginning would make management much easier later on.

Key considerations included:

• Separation of different environments (development, staging, production)
• Managing data for various services (Jenkins, Docker Registry, MinIO)
• Organizing image repositories (post, market, profile images)
• Backup and log management

I progressively developed the directory structure with these factors in mind.

Final Directory Structure 📂

After careful consideration, I decided on the following directory structure:

/moolmeow
├── services/
│   ├── jenkins/               → Jenkins data and settings
│   ├── registry/              → Docker Registry data
│   └── minio/                 → MinIO service data
│
├── storage/
│   ├── development/           → Development environment storage
│   │   ├── images/
│   │   │   ├── post/         → Post images
│   │   │   ├── market/       → Market images
│   │   │   └── profile/      → Profile images
│   │   └── uploads/          → Other user uploads
│   │
│   ├── staging/              → Staging environment storage (same structure as dev)
│   │   ├── images/
│   │   │   ├── post/
│   │   │   ├── market/
│   │   │   └── profile/
│   │   └── uploads/
│   │
│   └── production/           → Production environment storage (same structure as dev)
│       ├── images/
│       │   ├── post/
│       │   ├── market/
│       │   └── profile/
│       └── uploads/
│
├── shared/                    → Resources shared between environments
│   ├── certificates/          → SSL/TLS certificates
│   ├── secrets/               → Sensitive config files, keys, etc.
│   └── assets/                → Common assets (logos, icons, etc.)
│
├── configs/                   → All service configuration files
│   ├── kubernetes/
│   ├── jenkins/
│   ├── registry/
│   └── minio/
│
├── databases/                 → Database data files
│   ├── mysql/
│   └── redis/
│
├── backups/                   → System backups
│   ├── databases/
│   ├── configs/
│   └── storage/
│
└── logs/                      → Log files
    ├── kubernetes/
    ├── jenkins/
    ├── registry/
    └── applications/

Why Did I Choose This Structure? 🧩

1. Service Separation ⚙️

Initially, I wanted to separate data by service. Services like Jenkins, Docker Registry, and MinIO have different data characteristics and need to be managed separately. That’s why I created folders for each service under the /services directory.

2. Environment Separation 🌍

Data isolation from development to production is crucial! What if you accidentally overwrite production data in a development environment? 😱 Terrifying, right? That’s why I separated directories by environment under /storage.

3. Image Type Separation 🖼️

At first, I thought about storing all images in one place, but decided it would be more efficient to separate them by purpose for management and backup. Post images go to /post, market images to /market, and profile images to /profile.

4. Shared Resource Management 🤝

Resources used across all environments were separated into the /shared directory. Certificates and sensitive secret information especially needed separate management!

5. Centralized Configuration Files ⚙️

I decided to centrally manage all configurations in /configs. This makes change history management and backups much easier.

6. Backup and Log Management 📊

Backups and logs are essential for system operations! I chose to manage them systematically through the /backups and /logs directories.

Mount Configuration in Vagrant 🔄

After deciding on the directory structure, I added the following mount settings to my Vagrant file:

# Mount by main category
node_config.vm.synced_folder "#{base_path}/services", "/mnt/services", create: true
node_config.vm.synced_folder "#{base_path}/storage", "/mnt/storage", create: true
node_config.vm.synced_folder "#{base_path}/shared", "/mnt/shared", create: true
node_config.vm.synced_folder "#{base_path}/configs", "/mnt/configs", create: true
node_config.vm.synced_folder "#{base_path}/databases", "/mnt/databases", create: true
node_config.vm.synced_folder "#{base_path}/backups", "/mnt/backups", create: true
node_config.vm.synced_folder "#{base_path}/logs", "/mnt/logs", create: true

Initially, I considered more granular mounting, but decided to mount only by main category since having too many mount points could cause performance issues with VirtualBox shared folders.

Directory Creation Script 🛠️

Creating all these directories manually would be tedious. Here’s a script to create all directories at once:

#!/bin/bash

# Set base path
BASE_PATH="$HOME/Desktop/moolmeow"

# Create main directory
mkdir -p "$BASE_PATH"

# Create service directories
mkdir -p "$BASE_PATH/services/jenkins"
mkdir -p "$BASE_PATH/services/registry"
mkdir -p "$BASE_PATH/services/minio"

# Create environment-specific storage
for ENV in development staging production; do
  mkdir -p "$BASE_PATH/storage/$ENV/images/post"
  mkdir -p "$BASE_PATH/storage/$ENV/images/market"
  mkdir -p "$BASE_PATH/storage/$ENV/images/profile"
  mkdir -p "$BASE_PATH/storage/$ENV/uploads"
done

# Create shared resource directories
mkdir -p "$BASE_PATH/shared/certificates"
mkdir -p "$BASE_PATH/shared/secrets"
mkdir -p "$BASE_PATH/shared/assets"

# Create config directories
mkdir -p "$BASE_PATH/configs/kubernetes/base"
mkdir -p "$BASE_PATH/configs/kubernetes/development"
mkdir -p "$BASE_PATH/configs/kubernetes/staging"
mkdir -p "$BASE_PATH/configs/kubernetes/production"
mkdir -p "$BASE_PATH/configs/jenkins"
mkdir -p "$BASE_PATH/configs/registry"
mkdir -p "$BASE_PATH/configs/minio"

# Create database directories
mkdir -p "$BASE_PATH/databases/mysql"
mkdir -p "$BASE_PATH/databases/redis"

# Create backup directories
mkdir -p "$BASE_PATH/backups/databases"
mkdir -p "$BASE_PATH/backups/configs"
mkdir -p "$BASE_PATH/backups/storage"

# Create log directories
mkdir -p "$BASE_PATH/logs/kubernetes"
mkdir -p "$BASE_PATH/logs/jenkins"
mkdir -p "$BASE_PATH/logs/registry"
mkdir -p "$BASE_PATH/logs/applications"

# Set appropriate permissions
find "$BASE_PATH" -type d -exec chmod 755 {} \;

echo "MoolMeow project directory structure has been created at $BASE_PATH."

MinIO and Object Storage 💾

Initially, I planned to store files directly in the physical directory structure, but decided to adopt MinIO, an S3-compatible object storage. In MinIO, I plan to use the following bucket structure:

• Development Environment

  • dev-post-images
  • dev-market-images
  • dev-profile-images

• Staging Environment

  • stage-post-images
  • stage-market-images
  • stage-profile-images

• Production Environment

  • prod-post-images
  • prod-market-images
  • prod-profile-images

This allows consistent access to images through the S3 API!

Lessons Learned from Structure Design 🎓

Here are a few lessons I learned through this directory structure design:

1. It doesn’t have to be perfect from the start – It’s good to start simple and evolve as needed.
2. Consider scalability – Design in a way that won’t become chaotic when your service grows.
3. Environment separation is essential! – It’s important to clearly separate development, staging, and production environments.
4. Consider backup strategy together – Directory structure should align with backup and recovery strategies.

Conclusion 🎉

That’s how I designed the directory structure for the MoolMeow project. I hope this helps with your own projects! Feel free to leave any questions or comments below~ 😊