Neurelo Build Docs
Neurelo Build Docs
  • Introduction
    • Core Concepts
    • Key Features
  • Getting Started
    • Sign-in/Sign-up
    • Dashboard
      • Collapsible Sidebar
      • Light/Dark Mode
      • Account Settings
      • Audit Events
      • User Management
        • Permissions (Member v/s Admin)
      • Org Settings
    • Starting your Neurelo Project
      • Quick Start Guide
      • Step 1 - Add a Data Source
      • Step 2 - Build Definitions
      • Step 3 - Create an Environment
      • Step 4 - Create an API Key
      • Step 5 - Start Runners
      • Try your Neurelo APIs
  • "How to" Videos
    • Product Overview
    • Neurelo APIs & SDKs
    • Project Setup
    • Definitions
    • Environments
    • Data Sources
    • Organization Management
    • Creating and Using Custom Queries
    • Using the Schema Builder to build Relationships
    • Mock Data Generation
  • Definitions
    • Neurelo Schema Editor
      • Schema Builder
      • JSON/YAML Editor
      • Schema Visualization: Entity-Relationship Diagram (ERD)
    • Custom APIs for Complex Queries
      • Write and Commit Custom Queries
      • AI-Assisted Query Generation
      • Deploying Custom API Endpoints
      • Using Variables in your Custom Query
    • Branches and Commits
    • API Docs
  • Environments
    • Creating a new Environment
    • API Playground
    • Observability
    • Migrations
    • API Keys
  • Data Sources
    • PostgreSQL
    • MySQL
    • MongoDB
  • Guides
    • Provisioning Cloud Databases for using with Neurelo
      • PostgreSQL
        • AWS RDS (PostgreSQL)
      • MySQL
        • AWS RDS (MySQL)
      • MongoDB Atlas
    • Mock Data Generation
    • Wipe Data Source
    • Remote Git Repository for Definitions
      • Connecting a Remote Git Repo
      • Creating Commits from Neurelo
      • Syncing Branches
    • Data Viewer
    • Environment/Data Source Tags
    • How to work with Embedded documents and References in MongoDB
    • How to download and use the Postman Collection for your Project
    • Building Python applications with Postgres and FastAPI
    • CI Integration using Neurelo CLI
    • Schema Migrations
    • Schema AI Assist
    • Auto-Introspection
    • Access Policies
    • User Auth
      • Google
      • GitHub
      • GitLab
    • MongoDB Atlas - Migrate GraphQL to Neurelo
    • MongoDB Atlas - Migrate REST Data APIs to Neurelo
  • MongoDB Atlas - Migrate REST Data APIs to Neurelo
  • MongoDB Atlas - Migrate GraphQL APIs to Neurelo
  • Neurelo Schema Language (NSL)
    • Example 1 - DVD Rentals
    • Example 2 - Simple "Posts" App
    • Example 3 - Bookstore
  • Neurelo API Reference (REST)
    • Examples of Neurelo Auto-Generated REST API endpoints
      • Example 1 - Simple “Posts” application
      • Example 2 - "DVD Rentals" application
      • Example 3 - "Bookstore” application
      • cURL API Examples
  • Neurelo API Reference (GraphQL)
  • SDKs
    • TypeScript / JavaScript SDK
    • Go SDK
    • Python SDK
      • Python SDK Tutorial -- News Application
        • News Application using Neurelo’s Python SDKs
  • CLI (Preview Version)
  • Self-Hosted Neurelo Gateways
  • Tutorials
    • Building a Real Time Chat Application with Neurelo and MongoDB using Python
    • Building A Financial Terminal with Neurelo and MongoDB in Rust
    • Building a Restaurant Management System with Neurelo and MongoDB using GraphQL in just a few minutes
    • Bringing Neurelo’s Data APIs to Life Instantly with MySQL
  • Project Examples
  • References
    • Supported Databases
    • Supported OS and Browsers
  • Support
Powered by GitBook
On this page
  • Overview
  • Components of an Environment
  • Exploring the Environments Section:

Environments

PreviousAPI DocsNextCreating a new Environment

Last updated 1 year ago

Overview

Neurelo Environments align naturally with typical Software Development LifeCycles (SDLC) as developers work on their application from development to testing to production. Developers can create and run various environments and for each environment they can provision definitions (JSON Schema, APIs, Custom queries), and link the working database. This process ensures that all the necessary components work together as a run-time workspace, letting developers build, debug and test their changes seamlessly from their application to Neurelo's environment to the connected database.

For each project, Neurelo supports multiple environments allowing users to seamlessly operate across ephemeral dev and test workspaces to robust and persisting staging and prod deployments.

Components of an Environment

Three key components of each environment:

  1. Data Source: Each environment must connect with one database. Users can change the connected database anytime from Environment settings page.

  2. Definitions to be used: Each environment must have a commit of the definitions for the project attached to it. This ensures all the relevant meta-data (Schema, APIs, Custom Query Endpoints) are provisioned in this environment and map to the connected database. Users can change the attached definition for an environment by stopping the runners and changing the commit being used. Runners can be restarted once the commit has been changed.

  3. Runner: A Neurelo runner is the API handling engine for an environment, which handles the API requests between applications and dat sources. The runners operate by listening for incoming API requests, translating those requests into the corresponding datasource queries and then promptly responds with the relevant and appropriate information from the datasource.

To conserve platform resources, running environments which are inactive (no api calls) for more than 7 days may be automatically stopped. When the runners are auto-stopped for inactive environments, their configuration is not impacted. Runners can be restarted anytime by clicking on "Start Runners" when you need to use the environment again.

Exploring the Environments Section:

  • In the Environments section, you'll find various options and features for building, debugging, testing, and managing your APIs.

  • This section is a hub where you can interact with different aspects of your project, such as:

    • Experiment with APIs: Test and explore your REST and GraphQL APIs.

    • Observability Tools: Utilize tools to observe and monitor the performance and usage of your APIs.

    • Migrations: View and handle database migrations.

    • API Keys: Manage and create new API Keys as required for API access.

  • Additionally, you can adjust environment settings to suit your testing needs.