Sunbird RC
v2.0.0
v2.0.0
  • Learn
    • Introduction
    • Sunbird RC Overview
      • Why do we need Sunbird RC?
      • Core Capabilities
      • Core Registry Verbs
      • Workflows
      • What Sunbird RC is and what it's not? (WIP)
      • Possibilities
      • Demo Links
    • Technical Overview
      • Registry
        • High-Level architecture
        • Technical Specification Draft
        • Tech Stack and Requirements
      • Credentialling
        • High-Level Architecture
        • Technical Specification Draft
        • Tech Stack and Requirements
    • Adopters
    • Roadmap
  • Use
    • Getting started
      • Pre-requisites
      • Install Sunbird-RC
    • Developer's Guide
      • Functional Registry
        • Installation Guide
          • Registry CLI
            • Setup A Registry Instance
          • Manual installation through docker-compose
          • Production setup through Helm
        • Working with Source Code
        • Configurations
          • Frontend Configurations
          • Frontend - Proxy configuration
          • Audit Configuration
          • Notifications Configuration
          • View Templates Configuration
        • Schema Setup
          • Introduction To Schemas
          • Creating Your Own Schemas
          • Schema Configuration
          • Create Schemas With Custom Password
        • Setup the Backend
        • Setup the Frontend
        • Backup and Restore
          • PostgreSQL
            • SQL Dump
            • File System Level Backup
            • Continuous Archiving and Point-in-Time Recovery (PITR)
          • Cassandra
            • Snapshot-based backup method
            • Incremental backup method
            • Data Restore
        • Generic Identity And Access Management
        • Metrics
        • Custom Keycloak Build
        • Custom QR Code design
        • VC Verification Module
      • Credentialling Services
        • Installation Guide
          • Run for development
          • Docker compose based
          • Helm based
        • Configurations
        • Working with the Vault
    • Integrations
      • SSO with existing systems
      • Digilocker Meripehchaan SSO
      • Digilocker Integration
    • Connectors
      • G2P Connect
      • Open ID for Verifiable Credentials (OID4VCI)
    • Release Notes
      • Registry
      • Credentialling
    • Admin Portal
      • Login
      • Get Started
        • Create Schema
        • Attestation Workflows (WIP)
        • VC Template
          • Custom VC Template (WIP)
        • Ownership (WIP)
        • Publish (WIP)
      • Dashboard
  • API Reference
    • Registry APIs
      • Registry
        • Using The APIs
        • Create An Entity
        • Invite An Entity
        • Generate token
        • Generate admin token
        • Get An Entity
        • Get An Entity By Id
        • Update An Entity
        • Create A Property Of An Entity
        • Update A Property Of An Entity
        • Revoke a Credential
        • Delete An Entity
      • Schema
        • Create Schema
        • Get Schema
        • Update Schema
        • Delete Schema
        • Publish A Schema
      • Attestation API
        • Raise An Attestation
        • Get Attestation Certificate
      • Claims API
        • Get All Claims
        • Get Claim by ID
        • Attest A Claim
      • Discovery API
        • Search An Entity
      • File Storage API
        • Upload A File
        • Get Uploaded File
        • Delete A File/ Multiple Files
      • Metrics APIs
        • Get Count
        • Get Aggregates
    • Credentialling APIs
      • Identity Service APIs
      • Credential Schema APIs
      • Credential Issuance APIs
    • Other APIs
      • Sign API
      • Verify API
      • Swagger JSON API
      • Health API
  • Reference Solutions for Functional Registries
    • Education
      • Education Ecosystem
        • Installation
      • Education Registries
        • Installation
        • User Guide
    • Health Registries
      • Organ Registries
        • Frontend Setup
        • Backend Setup
        • User Guide
      • Health Facility Registry
    • Govt to Person (G2P)
  • Reference Solutions for Digital Credentials
    • Certificate Issuance
      • Installation(WIP)
      • User Guide
    • eLocker
      • High Level Diagram
      • Installation (WIP)
        • Frontend Setup E-locker
      • User Guide
    • Vaccination Platform
    • Skills & Work Credentials
    • Unified Learners Passport (ULP)
      • ULP Capabilities
      • Example Scenario
      • Technical Components (WIP)
      • Demo/Sandbox Links (WIP)
      • Installation Guide (WIP)
        • Frontend Setup
        • Installation through docker-compose
        • Dummy records setup for refrence
  • Links
    • Source Code
    • Releases & Changelogs
    • Website
    • Roadmap
    • Reference links
    • Design
  • Community
    • Discussion Forum
    • Contributors
    • Contributing
    • Contribution Guidebook
    • Code of Conduct
    • Community Events
    • Status By Track
  • HELP
    • Roadmap
    • FAQs
    • Glossary
    • Guide to Electronic Registries and Verifiable Credentials
      • Verifiable Credentials
        • What issues will Verifiable Credentials address?
        • What are the key roles in Verifiable Credentials?
        • What are the components of Verifiable Credentials?
        • What are the benefits of Verifiable Credentials?
        • Digital Credentials vs Verifiable Credentials
        • QR code vs Verifiable QR code
        • Use Cases
      • Electronic Registries
        • Evolution of Electronic Registries
        • What issues will Electronic Registries address?
        • Benefits of Electronic Registries
        • Registry vs Database
        • Design Principles
        • Use Cases
      • Leveraging Existing data stores
    • External Open Source Software Attributions
Powered by GitBook

Copyright (c) 2023 EkStep Foundation under MIT License

On this page
  • System requirements
  • Prerequisites
  • Deployment Steps
Edit on GitHub
  1. Use
  2. Developer's Guide
  3. Credentialling Services
  4. Installation Guide

Helm based

PreviousDocker compose basedNextConfigurations

Last updated 1 year ago

System requirements

Please note that the below numbers are only for reference, they will vary based on the business domain and scale.

  1. Kubernetes cluster (any version above v1.26.3)

    • Master Node: 2 vCPU, 4 GB RAM, Disc Size: 50 GB, Nodes: 1

    • Worker Nodes: 4 vCPU, 8 GB RAM, Disc size: 100 GB, Nodes: 3

  2. Bastion server: 2 vCPU, 4 GB RAM, Disc Size: 50GB

  3. Postgres with a read replica: 4 vCPU 8 GB RAM, Disc Size: 100GB

  4. ElasticSearch: 4 vCPU, 8 GB RAM, Disc Size: 100GB

  5. API Gateway

  6. Public domain

  7. Server for Minio: 2 vCPU, 4 GB RAM, Disc Size: 100GB (Optional)

  8. CDN / any other alternative for hosting UI

Prerequisites

  • Kubernetes Cluster with minimum 3 nodes

  • kubectl

  • Ingress ()

  • Postgres DB (create a database for keycloak and registry)

  • Domain URL (domain url mapped to Kubernetes cluster)

For more details refer to the High Level Architecture

Deployment Steps

Clone the Repo

```bash
git clone https://github.com/Sunbird-RC/deployment.git
cd helm/v2
```

Pre-check

kubectl cluster-info
kubectl get nodes
kubectl get ns
helm version

Create Namespace

kubectl create ns demo-registry

Feel free to use a different name for the namespace. Use the same name in the reset of the commands.

Vault Deployment

  • Please follow the steps to deploy the vault service. And use the same namespace that you have created in the previous step.

  • Unsealing a Vault is a critical process that involves reconstructing the master key from multiple key shares. This process is designed to provide added security.

Here are the basic steps to unseal a HashiCorp Vault:

Initialization (First-time setup): If you are initializing Vault for the first time, you'll need to run the following command to initialize the Vault and obtain unseal keys and the initial root token:

vault operator init

The output will provide unseal keys and an initial root token(<root_token>). Keep this information secure. (Make sure to have a copy of these keys or store it in a key.txt file securely)

Please make sure to use the <root_token> in the values.yaml. (VAULT_SECRET_TOKEN : base64 format of this <root_token>)

Unsealing: When Vault starts, it is sealed, and you need to unseal it using the unseal keys. You can unseal the Vault with the following command:

vault operator unseal

You will be prompted to enter an unseal key. Repeat this process with multiple unseal keys until the required threshold is reached.

Access Vault: After unsealing, you can access Vault using the initial root token or other tokens with appropriate permissions.

vault login <root_token>

Replace <root_token> with the initial root token obtained during the initialization.

Remember that unsealing requires a specified threshold (generally 3 ) of key shares to be provided, typically set during initialization. It's a security measure to ensure that a single compromised key is not enough to unseal the Vault.

Once you have the keys secured. You have to enable a KV engine

Enable KV engine in Vault

Use the vault secrets enable command to enable a KV engine. In this example, we're enabling the KV version 2 engine. You can replace secret-v2 with any path you prefer.

vault secrets enable -path=kv kv-v2

Create secrets

Convert all the passwords/secrets into base64 format and update these values in values.yaml file Secrets

  • VAULT_SECRET_TOKEN: Initial Root Token that you get when you deploy vault service (ex : hvs.*************)

  • DB_URL: Database Connection URL with username and password (Example: postgres://{{databse_usename}}:{{database_password}}@localhost:5432/{{database_name:sunbirdrc}})

VAULT_SECRET_TOKEN and DB_URL are mandatory secrets to be set. Other secrets can be set to empty

Modify configuration values

Configuration values related to vault address, base url and rootpath etc should be modified in values.yaml file.

Deploy helm charts

helm upgrade --install --namespace=demo-registry demo-registry helm_charts --create-namespace

Output

Release "demo-registry" does not exist. Installing it now.
NAME: demo-registry
LAST DEPLOYED: Thu May  4 17:02:08 2023
NAMESPACE: demo-registry
STATUS: deployed
REVISION: 1

Check if all the pods are running

kubectl get pods -n demo-registry

We use the hashicorp vault as the keystore (for more details you can refer ).

You can refer to this official documentation for helm-based deployment on a Kubernetes cluster. This deployment guide covers the steps required to install and configure a single HashiCorp Vault cluster.( )

This command enables the KV version 2 secrets engine at the specified path (kv). You can choose a different path based on your requirements. (But whatever name you provide here has to be used as the root_path: in the values.yaml)

Helm
https://kubernetes.github.io/ingress-nginx/deploy/
High-Level Architecture
here
https://developer.hashicorp.com/vault/tutorials/kubernetes/kubernetes-raft-deployment-guide
http://vault:8200/v1/kv