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
  • Understanding the Role of Runners:
  • Starting Runners in Neurelo
  • Completion of Project Setup
  • What's next?
  1. Getting Started
  2. Starting your Neurelo Project

Step 5 - Start Runners

PreviousStep 4 - Create an API KeyNextTry your Neurelo APIs

Last updated 1 year ago

Overview

A runner in Neurelo is the main component that executes and manages all API calls. In Neurelo's Cloud Data Access Platform, a runner is a part of every environment inside a project. Runners need to be started for the application to be able to handle API requests and process them against the configured data source within an environment. The final step in the onboarding process is to Start the Runners for the newly created environment within the project.

Understanding the Role of Runners:

  • Runners act as executing agents that manage the deployment and integration of your environment with the application.

  • Notes

    • Once runners for an environment are started, the environment becomes Active and certain changes to the core settings of your project cannot be made (as long as runners are active). If you need to change the settings for the environment, you may have to stop the runners, make the changes, and then restart the runners.

    • 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.

Starting Runners in Neurelo

The final step in setting up your Neurelo project is to start the runners. Here’s how to activate them:

  1. Locating the 'Start Runners' Section:

    • In the Quickstart guide on your Neurelo Dashboard, navigate to the "Start Runners" section.

  2. Activating the Runners:

    • Click on the "Start Runners" button.

    • Upon clicking, a notification toast will appear stating, "Runners will start shortly. This will take a few seconds."

    • The card will show the status of the runners being deployed

    • Once the runners have been successfully deployed, this step is complete

Completion of Project Setup

  • With the runners successfully started, you have now completed the essential steps for the onboarding of your Neurelo project. Your environment is ready for deployment and integration activities.

What's next?

  1. Try your Neurelo APIs using the API Playground

  2. Checkout the SDKs

  3. Create Custom Query Endpoints

By following these steps, you ensure that the runners, a vital component of your project's infrastructure in Neurelo, are correctly activated and ready to handle your deployment and continuous integration needs.