blocksos/prod-blocks-localization repository overview

⁠SELISE Blocks Localization

⁠Docker Image

blocksos/prod-blocks-localization:tagname

⁠Overview

SELISE Blocks Localization is the localization and translation management service for the SELISE Blocks platform. It provides the web-based interface and backend APIs required to manage languages, translation keys, glossaries, and localized resources.

The application combines an ASP.NET Core / .NET 10 backend with a React/Vite/TypeScript frontend, packaged as a single integrated application. The production frontend is built into the ASP.NET Core application's wwwroot directory and served by the API host. A separate background Worker is included for message consumption and background processing.

⁠Image Purpose

The Docker image:

blocksos/prod-blocks-localization:tagname

contains the production build of the Blocks Localization application and is intended to be used as the runtime image for deploying the Blocks Localization service.

The image includes:

• Blocks Localization Web Console
• REST APIs
• React production frontend
• ASP.NET Core backend
• Localization management functionality
• Translation key management
• Language management
• Glossary management
• Localization resource management
• Application services

⁠Technology Stack

⁠Backend

• ASP.NET Core
• .NET 10
• C#
• Kestrel web server
• REST APIs
• FluentValidation
• Health checks

⁠Frontend

• React
• TypeScript
• Vite
• npm

⁠Background Processing

• .NET Worker
• Background message consumers
• Blocks / Genesis messaging infrastructure

⁠Application Architecture

Blocks Localization follows an integrated frontend/backend architecture:

                    ┌──────────────────────┐
                    │     User / Client    │
                    └──────────┬───────────┘
                               │
                               ▼
                    ┌──────────────────────┐
                    │   Ingress / Gateway  │
                    └──────────┬───────────┘
                               │
                               ▼
              ┌─────────────────────────────────────┐
              │       SELISE Blocks Localization     │
              │                                     │
              │       ASP.NET Core / Kestrel        │
              │                                     │
              │  ┌─────────────┐ ┌────────────────┐ │
              │  │ REST APIs   │ │ React SPA      │ │
              │  └─────────────┘ └────────────────┘ │
              │                                     │
              │  Image:                             │
              │  blocksos/prod-blocks-localization  │
              │  :tagname                           │
              └────────────────┬────────────────────┘
                               │
              ┌────────────────┼────────────────┐
              ▼                ▼                ▼
         Database          Messaging       Blocks Services
                               │
                               ▼
                    ┌──────────────────────┐
                    │ Localization Worker  │
                    │                      │
                    │ Background Consumers  │
                    └──────────────────────┘

The React production build is served from server/Api/wwwroot by the ASP.NET Core API host, while the Worker handles background consumers separately.

⁠Container Port

The application API is configured to run on port:

5000

The Vite development server uses port:

4000

For the production Docker image, the primary application port is 5000.

Example Docker run command:

docker run -d \
  --name blocks-localization \
  -p 5000:5000 \
  blocksos/prod-blocks-localization:tagname

⁠Pull the Image

docker pull blocksos/prod-blocks-localization:tagname

⁠Kubernetes Deployment

The image can be deployed to Kubernetes using the following container configuration:

containers:
  - name: blocks-localization
    image: blocksos/prod-blocks-localization:tagname
    ports:
      - containerPort: 5000

The application can then be exposed through a Kubernetes Service and Ingress or an external application gateway.

⁠Image Naming

The Docker image follows the standard Docker image naming convention:

<organization>/<repository>:<tag>

For Blocks Localization:

⁠Runtime Configuration

The application supports BLOCKS_* environment variables for configuring the frontend and runtime environment.

Important configuration variables include:

⁠Runtime Dependencies

The Blocks Localization container provides the application runtime. External infrastructure and supporting services are deployed separately according to the target environment.

Depending on the deployment configuration, Blocks Localization may communicate with external services such as:

• Databases
• Message queues
• Blocks / Genesis services
• Vault / secret management
• Authentication and IAM services
• Logging services
• Monitoring services
• Tracing services
• Other SELISE Blocks platform services

These dependencies are not bundled into the application container.

⁠Production Deployment

The image is intended for production deployment environments where the container can be managed using Docker, Kubernetes, or another container orchestration platform.

A typical production setup consists of:

                    Internet / Users
                           │
                           ▼
                  ┌─────────────────┐
                  │ Gateway / WAF   │
                  └────────┬────────┘
                           │
                           ▼
                  ┌─────────────────┐
                  │ Kubernetes /    │
                  │ Container       │
                  │ Platform        │
                  └────────┬────────┘
                           │
                           ▼
              ┌─────────────────────────────┐
              │    Blocks Localization      │
              │                             │
              │ blocksos/prod-blocks-       │
              │ localization:tagname        │
              │                             │
              │ ASP.NET Core + React        │
              └────────────┬────────────────┘
                           │
              ┌────────────┼─────────────┐
              ▼            ▼             ▼
           Database     Messaging    Platform APIs
                           │
                           ▼
                 ┌───────────────────┐
                 │ Localization      │
                 │ Worker            │
                 └───────────────────┘

⁠Source Repository

The complete source code and documentation for SELISE Blocks Localization are available on GitHub:

GitHub Repository:

https://github.com/SELISEdigitalplatforms/blocks-localization

⁠License

This project is licensed under the MIT License.

The repository includes an MIT LICENSE file.

⁠Summary

SELISE Blocks Localization is the localization and translation management service for the SELISE Blocks platform. The blocksos/prod-blocks-localization:tagname Docker image provides a deployable production container for the service, combining the ASP.NET Core backend, REST APIs, React-based web console, and supporting application components.