DOCSEARCHbyAlgolia
Submit Docs

Haulrest Blog by Austin (Hyunuk Lee)

website·Indexed 31 days ago

https://blog.haulrest.me/

A technical blog and project portfolio by Austin (Hyunuk Lee) focusing on backend engineering and infrastructure. Content covers Kubernetes migration (Azure AKS, Amazon EKS), Karpenter, KEDA, Argo CD, Istio, HAProxy, Terraform, and Node.js PDF processing, alongside personal reflections on development processes and AI tools like Cursor.

Tokens
21.8K
Snippets
53
Records
147
Agent score
52%

What's inside Haulrest Blog

  1. Overview of AE Check tool

    AE Check is a character encyclopedia and insights tool for the mobile game 'Another Eden' by WFS. It allows users to record and save character growth status, download this information as images for sharing, and use it for game-related inquiries to compensate for the game's limited in-game data visibility and UI/UX shortcomings.

  2. Overview of KEDA for Kubernetes Autoscaling

    KEDA (Kubernetes Event-driven Autoscaling) is a CNCF Graduated Project that allows for dynamic scaling of containers based on various event sources (e.g., message queues, databases, or specific time intervals). It works by defining a ScaledObject resource, which monitors external events and automatically updates the state of a Horizontal Pod Autoscaler (HPA) to adjust the number of Pods.

  3. Overview of Micro Frontend Architecture (MFA)

    Micro Frontend Architecture (MFA) is a methodology where a frontend service is split into smaller, independent units. Each unit can be developed and deployed separately and then combined into a single integrated service. This approach is particularly beneficial for large-scale services or organizations as it improves maintainability, enables component reuse, and allows teams to work independently.

  4. Overview of BA Torment party-finding helper

    BA Torment is a helper tool for finding parties in the Total Assault and Tactical Challenge modes of the mobile game Blue Archive. It processes clear data from the Japanese server (which typically releases content 3 months before the Global/Korean servers) to provide users with information and filtering options to plan character growth and resource management.

  5. Address application-level limitations when using Kubernetes

    Kubernetes cannot solve fundamental application architecture issues. Developers should be aware of the following constraints:

    • Image Size: Heavy monolithic images lead to slow image pulls and long startup/shutdown times, which can hinder the effectiveness of Horizontal Pod Autoscalers (HPA).
    • WebSocket Connections: Since Pod termination disconnects WebSockets, aggressive auto-scaling can increase 502 errors. Consider separating WebSocket services or finding alternative connection management strategies.
    • Process Model: Using multi-process managers like Supervisor inside a container contradicts the Kubernetes 'Single Process' principle, often leading to excessive resource allocation per Pod.
    • Graceful Shutdown: Even with PreStop hooks and graceful shutdown configurations, network interruptions may persist if the application itself is not lightweight and responsive.

  6. General workflow for developing a game-related side project

    Follow these steps to take a game-related idea from concept to a live service:

    1. Ideation: Identify a pain point while playing or listen to other users' complaints about missing tools.
    2. Data Sourcing: Determine the method for obtaining raw data (Official API, Unofficial, or Manual).
    3. Planning: Sketch the UI and determine how data will be displayed. Keep planning flexible as requirements often change during development.
    4. Development: Build the application (Web is recommended for easier deployment and updates).
    5. Deployment (Optional): Make the service public for others to use.
    6. Feedback & Iteration (Optional): Collect user feedback to improve the service.
    7. Maintenance (Optional): Update the project in alignment with official game updates.

  7. Frontend technology stack

    The frontend stack is divided by platform:

    • Web: React or Next.js with TypeScript for type safety. Playwright is used for E2E testing (Storybook is not used).
    • Mobile: Flutter is used for cross-platform development due to its performance and lightweight nature compared to React Native.
    • Auth: Supabase SDK is used for simplified authentication handling.

  8. Use Fable 5 for zero-base problem solving and architecture design

    Fable 5 is particularly effective for 'Unknown tasks'—problems where the starting point or the required actions are unclear. It excels at investigating and structuring ambiguous problems, making it suitable for:

    1. Designing system architectures and initial demos from scratch (zero-base).
    2. Creating initial drafts for complex solutions that must remain independent of existing code while sharing core logic.
    3. Analyzing difficult problems to find solutions and creating complex plans.

    While Fable 5 is strong at high-level planning and structural design, the author suggests delegating the actual implementation (coding) to models like Opus or Codex once the direction is established.

  9. Use Karpenter for dynamic EKS node provisioning

    Karpenter is an open-source autoscaler that provisions nodes dynamically by observing Pod requirements and calling the EC2 API directly. Unlike the standard Cluster Autoscaler, it selects the optimal VM based on defined constraints, reducing wasted resources and enabling faster provisioning (typically under 1 minute). It manages self-managed node pools using EC2NodeClass and NodePool configurations.

  10. Backend technology stack and architectural direction

    The backend architecture aims for flexibility across protocols (API, MCP) and ease of maintenance through a common structure. Key principles include:

    • Language Choice: Go is the primary language for all services due to performance and small image size. Python is used as a secondary language for its rich library ecosystem (e.g., LangChain) and is managed using uv.
    • Architecture: Prefers Microservices Architecture (MSA).
    • Protocol Independence: Business logic is decoupled from protocols. The terms Input and Output are used instead of Request and Response to ensure future-proofing.
    • Interface Flow: API/MCP interfaces handle only protocol-specific logic following a strict flow: Auth $\rightarrow$ Input Extraction/Validation $\rightarrow$ Business Logic Call $\rightarrow$ Return.
    • RDBMS Implementation: Uses sqlc for database logic instead of GORM to ensure better performance.

  11. Benefits of choosing games for side projects

    Building side projects around games is effective for developers because:

    • Reduced Ambiguity: Games have predefined rules and systems, which removes the 'blank page' problem often found in starting a project.
    • High User Engagement: Especially in regions like South Korea, the large gaming population makes it easier to find users and gather feedback.
    • Maintenance Experience: Game updates force the developer to update the project, providing a natural cycle for learning maintenance and deployment processes.
    • Availability of Data: Many games provide structured data via APIs, reducing the friction of initial development.

  12. Tiny Clover Project Overview

    Tiny Clover is a core project designed to expand personal interests and projects using AI and Model Context Protocol (MCP). The goal is to create a full product that provides a backend via MCP, integrates multiple LLM APIs, and includes a payment system to provide helpful services to users with similar interests while driving technical growth.