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
  • Setup with GitHub using Deploy Keys
  • Test the Connection
  1. Guides
  2. Remote Git Repository for Definitions

Connecting a Remote Git Repo

PreviousRemote Git Repository for DefinitionsNextCreating Commits from Neurelo

Last updated 1 year ago

In this example, we will be using as a representative example of a platform where you have your git repository. You can use similar steps to connect git repos in other plaforms such as , and others.

Setup with GitHub using Deploy Keys

Let’s say we have a private GitHub Repository named my-app and want to use it for the Neurelo definitions in the project. The recommended way to connect the repository with Neurelo is to use the “Deploy Keys” feature.

  • Copy the SSH URL for the Repository from GitHub

  • Next, Create a new Project in Neurelo, set the name and the database engine, check the “Use Remote Git Repository” check box, and click “Next.”

  • This will open the Repository Configuration. Select the “SSH” mode and enter the SSH URL we copied from GitHub in the “Repository URL.” In our example, the main is the default branch.

Next we need to add the Neurelo Public Key into the GitHub Repository

  • Copy the Public Key from the Neurelo project

  • Navigate to the Settings tab in your GitHub repository and open the “Deploy keys” page

  • Paste the Public Key from the Neurelo Remote Git Configuration Dialog. Ensure that “Allow write access” is enabled so Neurelo can commit the definitions.

  • Once added, the key will show up on the Deploy Keys page. It should have the “Read/write” permissions.

Test the Connection

  • Once the Public key has been added, click “Test Connection” to ensure Neurelo can connect with your repository.

  • Wait for Neurelo to try to test the connection. Upon success, you will see a “Remote repo connection test completed successfully” toast. Click on “Create.”

  • If you navigate to the “Definitions” and open the history, you should be able to see the commits from your Git Repository.

Github
Gitlab
BitBucket