StaticBackend is a simple backend server API handling user mgmt, database, storage and real-time component

StaticBackend logo

StaticBackend - simple backend for your apps

StaticBackend is a simple backend that handles user management, database, file storage, forms, and real-time experiences via channel/topic-based communication for web and mobile applications.

You can think of it as a lightweight Firebase replacement you may self-host. No vendor lock-in, and your data stays in your control.

Table of content

What can you build

I built StaticBackend with the mindset of someone tired of writing the same code over and over on the backend. If your application needs one or all of user management, database, file storage, real-time interactions, it should be a good fit.

I'm personally using it to build SaaS:

How it works / dev workflow

The main idea is that StaticBackend is your backend API for your frontend apps. A performant free and open-source Firebase alternative.

Note that it can also be used from your backend code as well.

Once you have an instance running and your first app created, you may install the JavaScript client-side library:

$> npm install @staticbackend/js

Let's create a user account and get a session token and create a task document in the tasks collection:

{ const res = await bkn.login("[email protected]", "password"); if (!res.ok) { console.error(res.content); return; } token = res.content(); createTask(); } createTask = async () => { const task = { desc: "Do something for XYZ", done: false }; const res = bkn.create(token, "tasks", task); if (!res.ok) { console.error(res.content); return; } console.log(res.content); } ">
import { Backend } from "@staticbackend/js";

const bkn = new Backend("your_public-key", "dev");

let token = "";

login = async () => {
	const res = await bkn.login("[email protected]", "password");
	if (!res.ok) {
		console.error(res.content);
		return;
	}
	token = res.content();

	createTask();
}

createTask = async () => {
	const task = {
		desc: "Do something for XYZ",
		done: false
	};

	const res = bkn.create(token, "tasks", task);
	if (!res.ok) {
		console.error(res.content);
		return;
	}
	console.log(res.content);
}

The last console.log prints

{
	"id": "123456-unique-id",
	"accountId": "aaa-bbb-unique-account-id",
	"desc": "Do something for XYZ",
	"done": false
}

From there you build your application using the database CRUD and query functions, the real-time component, the storage API, etc.

You may use server-side libraries for Node and Go or use an HTTP client and use your preferred language.

Get started with the self-hosted version

Get started with self-hosted version

Click on the image above to see a video showing how to get started with the self-hosted version.

Please refer to this guide here.

We also have this blog post that also includes the above video.

If you have Docker & Docker Compose ready, here's how you can have your server up and running in dev mode in 30 seconds:

$> git clone [email protected]:staticbackendhq/core.git
$> cd core
$> cp .demo.env .env
$> docker build . -t staticbackend:latest
$> docker-compuse -f docker-compose-demo.yml up

Test your instance:

$> curl -v http://localhost:8099/db/test

You should get an error as follow:

< HTTP/1.1 401 Unauthorized
< Content-Type: text/plain; charset=utf-8
< Vary: Origin
< Vary: Access-Control-Request-Method
< Vary: Access-Control-Request-Headers
< X-Content-Type-Options: nosniff
< Date: Tue, 03 Aug 2021 11:40:15 GMT
< Content-Length: 33
< 
invalid StaticBackend public key

This is normal, as you're trying to request protected API, but you're all set.

The next step is to visit http://localhost:8099 and create your first app. Please note that in dev mode you'll have to look at your docker compose output terminal to see the content of the email after creating your app.

Documentation

We're trying to have the best experience possible reading our documentation.

Please help us improve if you have any feedback.

Documentation with example using our libraries or curl:

Librairies & CLI

We provide a CLI for local development if you want to get things started without any infrastructure and for prototyping.

You can use the CLI to manage your database and form submission. This is the only interface we currently have to interact with your database, other than via code. There will be a web UI available before v1.0 is released.

We have a page listing our client-side and server-side libraries.

Examples

If you'd like to see specific examples please let us know via the Discussions tab.

Here's the examples we have created so far:

Deploying in production

We've not written anything yet regarding deploying, but once you have the core` built into a binary and have access to MongoDB and Redis in production you should be able to deploy it like any other Go server.

We'll have documentation and an example soon for deploying to DigitalOcean.

Feedback & contributing

If you have any feedback (good or bad) we'd be more than happy to talk. Please use the Discussions tab.

Same for contributing. The easiest is to get in touch first. We're working to make it easier to contribute code. If you'd like to work on something precise let us know.

Open source, sponsors, paid SaaS

You may read here why we've decided to open source StaticBackend.

Hopefully we can start getting sponsorship so the open source version development and future is secure.

We're also offering paid subscription for a fully managed version of SB.

Spread the words

It would means the world to us if you could help us spread the words about StaticBackend. A tweet, a blog post, any visibility is helpful and I (Dominic) personally thanks you for this.

I've failed at getting any kind of traction with StaticBackend on its closed source form. I think developer tools like this need to be open source.

I believe in the product, it solves a pain I have for so long, but I'm hoping others will also get value out of it and will be excited about the project.

Owner
StaticBackend
Backend as a service without vendor locked-in.
StaticBackend
Comments
  • Create web UI for file storage mgmt

    Create web UI for file storage mgmt

    A simple web UI to upload, view and delete files.

    Uploading and deleting should trigger a message since if the user was using that file somewhere they might want to update the document(s) where it's used.

  • feat: add logger to have better experience with work on app

    feat: add logger to have better experience with work on app

    Is your feature request related to a problem? Please describe. As a new contributor, I can say that it's really hard to develop the application without logging because you can get some errors, and "fmt.Println" doesn't give all information about an error. And sometimes he can't print it.

    Describe the solution you'd like We can use some modern, custom logger ex: "zap", "logrus" or "zerolog" which will write log's into file and console. It will more comfortable then use default "fmt.Println" or "log.Println")

    I see it as a structure that will be passed to other functions as an argument. This structure will configurable with "LOG_LEVEL" or we can do it with "APP_ENV". For ex: if "APP_ENV" is equal to dev we will log messages from all levels but if it equal to prod we will log only error or critical levels)

    Additional context People from Discord say that we should use "zerolog" and how I seen it looks not bad. How do you think should we implement it or not?

  • Embed UI templates via go:embed

    Embed UI templates via go:embed

    By implementing the backend package I discover that the //go:embed directive works when importing external package.

    Since the CLI uses the core package to expose a fully working local dev server, it would be nice to embed the templates for the web admin UI.

    That way they'd be available from the CLI.

    We'd use them like this in the render.go file:

    //go:embed templates
    var templFS embed.FS
    

    Once this is done, the loadTemplates in render.go line:20 should be changed to use the templFS above. Use the the io/fs instead of os to ReadDir.

  • Add Count functions in database

    Add Count functions in database

    Sometimes, it's useful to have a count of how many records there is in a collection with or without filters.

    Adding a Count functions in all 3 database engine supported would involves the following:

    1. Adding the function in the Persister interface in the database package
    2. Implement it for the postgresql, mongo, and memory database engine
    3. Add an endpoint in the backend API

    Depending if you write your tests first or not, but having a tests in the main package as well as inside the different db engine ones would be nice.

    Since the return type would be int64, error there's no need to implement a generic function in the backend's Database[T] functions set.

    I'd see the following function prototype:

    // Count returns the numbers of entries in a collection based on optional filters
    Count(auth model.Auth, dbName, col string, filters map[string]interface{})` (int64, error)
    

    The filters would be optional. See how the UpdateMany function also uses similar filters

    For the endpoint, we could have a new route in server.go around the routes starting with /db and have a new one like /db/count/ which would call an handler defined in db.go that would accept POST request with the optional filters (look in db.go for example of the UpdateMany).

    p.s. the typical database security apply, so the standard permission checks would happen before the optional filters

  • Add the PublishDocument event trigger after the bulk update

    Add the PublishDocument event trigger after the bulk update

    Need to add the PublishDocument trigger to the updateDocuments functions located in database/postgresql/base.go:265 and database/mongo/base.go:369

    It will require a new function, something that can grab multiple documents by ID to publish the changed documents they'll need to be fetched, to avoid the usage of the GetByID in a loop.

  • chore: add local cache sub/pub events

    chore: add local cache sub/pub events

    Add a local observer for the Pub/sub cache events #42

    Observer provides a possibility to subscribe to a specific event and publish a message for all subscribers of the channel. The memObserver struct contains a map with a slice of subscribers where the key of the map is a specific channel.

    The subscriber is basically a wrapper for the channel that is listening for the changes

  • [refactor]: Remove ShiftPath and replace with getURLPart

    [refactor]: Remove ShiftPath and replace with getURLPart

    For simplicity the ShiftPath should be removed and all its usage should be replace with the getURLPart.

    ShiftPath is takiing the request path and return the last value of the URL and return a modified shrinked version:

    // URL: /a/b/c
    r.URL.Path, c := ShiftPath(r.URL.Path) // c = "c"
    r.URL.Path, b := ShiftPath(r.URL.Path) // b = "b"
    

    The simpler getURLPart function gets an URL value by index:

    // URL: /a/b/c
    c := getURLPart(r.URL.Path, 3) // notice that indexes starts at 1, not 0. a is at idx 1, b at 2 and c at 3
    

    I'd start this refactor by removing the ShiftPath function from url.go. In fact, I'd delete the entire url.go file and go build to fix compile error.

    Before replacing a call to ShiftPath we need to make sure we know the proper index we want to use with the getURLPart.

    For this, reverting to the URL in server.go for this handler would be how I'd ensure.

  • Expose an HTTP client to the function runtime

    Expose an HTTP client to the function runtime

    The server-side functions run inside a custom JavaScript runtime. It only support bare JavaScript and has additional functionalities added via the VM.

    One useful function would be to expose a way to perform HTTP requests from the function.

    See function/runtime.go line:110.

    Adding a helper function like fetch to keep "consistent" with the JS eco-system. Or something like webreq

    I can see the function taking the following as parameters:

    // example from the function code PoV
    const resp = webreq("POST", "https://myurl.com", {hello: "world"}, {"MY-HEADER-KEY": "something"});
    

    This would accept the HTTP Method, URL, Body as JSON, Header as a map.

    And this helper function would return:

    type HTTPResponse struct {
      Status int `json:"status"
      Body string `json:"body"
    }
    
  • fix(storage/upload): change arguments in ext to avoid error in ui

    fix(storage/upload): change arguments in ext to avoid error in ui

    As I know the name field is optional and sometimes user won't use it. But in our UI we need to know file ext without . Actually it would be better to use original file name with correct ext instead of using optional field

  • Expose an HTTP client to the function runtime

    Expose an HTTP client to the function runtime

    Add a function runtime helper complaint with fetchAPI

    Currently, the SB doesn’t have a way to call HTTP/S endpoints from the SB’s function.This PR adds a helper called “fetch”, which is compliant with JS Fetch API. The current implementation supports only GET, PUT, POST, PATCH, and DELETE. It can be extendedfurther.

    Fixes #43

  • Error when list/query for not created tables

    Error when list/query for not created tables

    Describe the bug The creation of tables occur on the first insertion (call to CreateDocument function.

    For this reason, code that tries to get records from a table that did not had a created document will return an error.

    To Reproduce

    1. Start the CLI $ backend server
    2. Issue a ListDocument request
    $ curl -H "SB-PUBLIC-KEY: dev-memory-pk" -X POST -d '{"email": "[email protected]", "password": "devpw1234"}' http://localhost:8099/login
    $ curl -H "SB-PUBLIC-KEY: dev-memory-pk" -H "Authorization: Bearer session-token-you-got-above" http://localhost:8099/db/new-table-here
    

    Error returned:

    collection not found
    

    Expected behavior

    Might be better to return an empty slice instead of an error. The "standard" web CRUD flow is to create the "listing" page before users go to create entity.

    Output of staticbackend -v

    StaticBackend version v1.4.0-rc2-13-gb392f7a | 2022-08-23.05:33:15 (b392f7a)

    Additional context

    This should be the same behavior for all 3 database package: postgresql, mongo, and memory.

  • chore(deps): bump github.com/aws/aws-sdk-go from 1.27.2 to 1.33.0

    chore(deps): bump github.com/aws/aws-sdk-go from 1.27.2 to 1.33.0

    Bumps github.com/aws/aws-sdk-go from 1.27.2 to 1.33.0.

    Changelog

    Sourced from github.com/aws/aws-sdk-go's changelog.

    Release v1.33.0 (2020-07-01)

    Service Client Updates

    • service/appsync: Updates service API and documentation
    • service/chime: Updates service API and documentation
      • This release supports third party emergency call routing configuration for Amazon Chime Voice Connectors.
    • service/codebuild: Updates service API and documentation
      • Support build status config in project source
    • service/imagebuilder: Updates service API and documentation
    • service/rds: Updates service API
      • This release adds the exceptions KMSKeyNotAccessibleFault and InvalidDBClusterStateFault to the Amazon RDS ModifyDBInstance API.
    • service/securityhub: Updates service API and documentation

    SDK Features

    • service/s3/s3crypto: Introduces EncryptionClientV2 and DecryptionClientV2 encryption and decryption clients which support a new key wrapping algorithm kms+context. (#3403)
      • DecryptionClientV2 maintains the ability to decrypt objects encrypted using the EncryptionClient.
      • Please see s3crypto documentation for migration details.

    Release v1.32.13 (2020-06-30)

    Service Client Updates

    • service/codeguru-reviewer: Updates service API and documentation
    • service/comprehendmedical: Updates service API
    • service/ec2: Updates service API and documentation
      • Added support for tag-on-create for CreateVpc, CreateEgressOnlyInternetGateway, CreateSecurityGroup, CreateSubnet, CreateNetworkInterface, CreateNetworkAcl, CreateDhcpOptions and CreateInternetGateway. You can now specify tags when creating any of these resources. For more information about tagging, see AWS Tagging Strategies.
    • service/ecr: Updates service API and documentation
      • Add a new parameter (ImageDigest) and a new exception (ImageDigestDoesNotMatchException) to PutImage API to support pushing image by digest.
    • service/rds: Updates service documentation
      • Documentation updates for rds

    Release v1.32.12 (2020-06-29)

    Service Client Updates

    • service/autoscaling: Updates service documentation and examples
      • Documentation updates for Amazon EC2 Auto Scaling.
    • service/codeguruprofiler: Updates service API, documentation, and paginators
    • service/codestar-connections: Updates service API, documentation, and paginators
    • service/ec2: Updates service API, documentation, and paginators
      • Virtual Private Cloud (VPC) customers can now create and manage their own Prefix Lists to simplify VPC configurations.

    Release v1.32.11 (2020-06-26)

    Service Client Updates

    • service/cloudformation: Updates service API and documentation
      • ListStackInstances and DescribeStackInstance now return a new StackInstanceStatus object that contains DetailedStatus values: a disambiguation of the more generic Status value. ListStackInstances output can now be filtered on DetailedStatus using the new Filters parameter.
    • service/cognito-idp: Updates service API

    ... (truncated)

    Commits

    Dependabot compatibility score

    Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.


    Dependabot commands and options

    You can trigger Dependabot actions by commenting on this PR:

    • @dependabot rebase will rebase this PR
    • @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
    • @dependabot merge will merge this PR after your CI passes on it
    • @dependabot squash and merge will squash and merge this PR after your CI passes on it
    • @dependabot cancel merge will cancel a previously requested merge and block automerging
    • @dependabot reopen will reopen this PR if it is closed
    • @dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
    • @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
    • @dependabot use these labels will set the current labels as the default for future PRs for this repo and language
    • @dependabot use these reviewers will set the current reviewers as the default for future PRs for this repo and language
    • @dependabot use these assignees will set the current assignees as the default for future PRs for this repo and language
    • @dependabot use this milestone will set the current milestone as the default for future PRs for this repo and language

    You can disable automated security fix PRs for this repo from the Security Alerts page.

  • Implement a full-text search capability

    Implement a full-text search capability

    A full-text catalog is a useful feature for most application.

    This is a proposal of how I'd see this feature being added.

    Overall concept

    To keep things simple I think SB would handle 1 reserve table/collection that supports FTS. Its schema could be similar to this:

    Name: sb_fts (this would be on all tenant database)

    id:string auto id
    accountId:string the account owner
    referenceId:string the id this item refers to
    searchField:string the fts content to search in
    previewData: JSON representation of a tiny "view" of the referenced object
    

    An database would have only one table to perform full-text search.

    The full-text index would index what's inside the searchField

    The caller would receive a previewData list of all matches. This is useful since most full-text search output to a search results usually. Having a quick way to display the important data for matches is handy.

    The referenceId is the id of the referenced entity. Continuing our analogy of a search result, one could build a URL from this ID to load the entire entity.

    The "how"

    PostgreSQL and MongoDB support full-text search natively. If SQLite is implemented (#63 ) it's also supported in SQLite.

    The memory database impl would most certainly not offer FTS. Or if time allow, we could leverage an in-memory text search. TBD.

    We could have a simple Search function in the Persister interface. Each database provider would implement their own version.

    We'd also require a function like IndexContent (name to be refine) in the Persister interface.

    An example of those function prototypes could be:

    // in model
    type FullTextData struct {
      ID string `json:"id"`
      AccountID string `json:"accountId"
      ReferenceID string `json:"refId"
      SearchField string `json:"searchField"
      PreviewData map[string]any `json:"previewData"
    }
    func Search(auth model.Auth, search string) ([]FullTextData, error)
    func IndexContent(auth model.Auth, data FullTextData) error
    

    To be careful

    Since the sb_fts hold preview data of real entities in other table/collection they'd need to reflect updated values and be removed when the main entity is deleted.

    At this moment, I'm not certain if this would be the responsibility of the dev or SB.

    The deverloper could listen to database events and create functions that react to updates and deletes and apply the desire changes to the fts table/collection.

    If it's SB's responsibility, I don't see how it can know about the schema the previewData should have.

    Some ideas:

    1. Maybe it can perform a get by id and updates the previewData map with matching keys from the updated document. This remove SB from having to know anything about user's data.

    For now, that's the only way that comes to mind. TBD.

    API endpoint

    This could be a reserved word like /db/fts this means that a user could never have a table/collection called fts, maybe could be sbfts. TBD.

    This would need to be added to all client library as well as the backend package for Go devs using SB directly.

    Deploying those changes

    This will most certainly require a new SQL migration for PostgreSQL. And since the sb_fts table is defined in "user land", this migration would need to add it for all existing database (PG schema).

    This will be the first time a changes need to update all users' databases. This will require testing before going into production.

  • Implement a SQLite provider

    Implement a SQLite provider

    A sqlite package in the database would allow people to have the full experience without having to install any external database server engine. Couple with the memory Cache implementation, this would make StaticBackend single binary fully functional without any external dependencies.

    This addition involves implementing the database.Persister interface in a new sqlite package.

    Once it's done, we'd need to add the SQLite database open in the backend package by handling the two value for the config's DatabaseURL and DataStore. DataStore of sqlite for SQLite.

    Since SQLite isn't allowing multiple schema, replicating the multi-tenant aspect of PostgreSQL and Mongo could be done by prefixing the table names.

    I'd assume that someone using SQLite would most certainly not handle multi-tenant in their application.

    Since SQLite 3.9 is possible to handle JSON (inserting and querying), so the implementation would replicate more of less PostgreSQL's.

  • Expose the Volatilizer interface functions to the server-side runtime

    Expose the Volatilizer interface functions to the server-side runtime

    There's missing functions from a server-side function PoV from the internal.Volatilizer (Cache / PubSub) interface that would be useful to have in functions.

    The custom server-side runtime is implemented in the function package in the runtime.go file.

    At this moment the runtime adds functions that are made available from the function's JavaScript interpreter.

    In the function addVolatileFunctions in runtime.go line:391 we would need to add the following functions from the interface.

    Look at the send function for an example

    cacheGet and cacheSet would wrap the interface's GetType and SetType functions which will handle passing string as well as any object.

    inc and dec would map to the interface's Inc and Dec functions

    Lastly queueWork maps to the interface's QueueWork function

    Adding those runtime functions will enable a world of possibility from server-side function, even though they run inside a sandboxed runtime.

  • Fix TestHtmlToPDF occasional issue

    Fix TestHtmlToPDF occasional issue

    Describe the bug GitHub actions sometimes failed due to this test sometimes raising an error. I've seen it happened once in development as well.

    error line:128: context deadline exceeded

    Lines in question:

    if resp.StatusCode > 299 {
      b, err := io.ReadAll(resp.Body)
      if err != nil {
        t.Fatal(err)
      }
      t.Log(string(b))
      t.Errorf("expected status 200 got %s", resp.Status)
    }
    

    To Reproduce

    1. First remove the t.Skip in this test in extras_test.go line: 116
    2. Running this test multiple times in a row should trigger the issue:
    $ make thistest TestHtmlToPDF
    

    Expected behavior This should always work and not trigger this error

    Output of staticbackend -v This flag isn't implement yet.

  • Create a dedicated accounts/users page in the web UI to view/manage users

    Create a dedicated accounts/users page in the web UI to view/manage users

    Since 5351407 the web UI database page is not displaying the system collections, the one prefixed with sb_ owned by StaticBackend.

    In #26 there were an item regarding adding a dedicated page for user management. This is its dedicated issue.

    I'd see a simple table listing the sb_accounts and when clicking on an account we would see its users from sb_tokens either directly in the same page or in a new page for this account.

    There's currently no way to list accounts and users from an account. Here's how I'd approach this:

    1. In persistor.go I'd add two new functions in the // system user account function s section. ListAccounts and ListUsers
    2. An implementation for the postgresql, mongo, and memory providers will be required.
    3. In the ui.go create two new hanglers like listAccounts and listUsers. The listAccounts does not need much parameters, but listUser will require an accountId.
    4. Add the two route in server.go line:227 near webUI := ui{} block of routes.

    Additional thoughts.

    • Could be nice to be able to search by email for an account / user in that page.
    • Ideally, the account would be sorted by last created.
Tigris is a modern, scalable backend for building real-time websites and apps.

Tigris Data Getting started These instructions will get you through setting up Tigris Data locally as Docker containers. Prerequisites Make sure that

Dec 27, 2022
The Container Storage Interface (CSI) Driver for Fortress Block Storage This driver allows you to use Fortress Block Storage with your container orchestrator

fortress-csi The Container Storage Interface (CSI) Driver for Fortress Block Storage This driver allows you to use Fortress Block Storage with your co

Jan 23, 2022
A simple go application that uses Youtube Data API V3 to show the real-time stats for a youtube channel such as the subs, views, avg. earnings etc.
A simple go application that uses Youtube Data API V3 to show the real-time stats for a youtube channel such as the subs, views, avg. earnings etc.

Youtube-channel-monitor A simple go application that uses Youtube Data API V3 to show the real-time stats for a youtube channel such as the subs, view

Dec 30, 2021
A simple program to automatically backup a database using git. Err handling by Sentry, Reporting by Betteruptime. Made with 🩸 , 😓 & 😭

backup What is this? A Simple program to automatically backup a database using git. Err handling by Sentry, Uses heartbeats by Betteruptime Made with

Nov 4, 2022
Simple Kubernetes real-time dashboard and management.
Simple Kubernetes real-time dashboard and management.

Skooner - Kubernetes Dashboard We are changing our name from k8dash to Skooner! Please bear with us as we update our documentation and codebase to ref

Dec 28, 2022
Reconstruct Open API Specifications from real-time workload traffic seamlessly
Reconstruct Open API Specifications from real-time workload traffic seamlessly

Reconstruct Open API Specifications from real-time workload traffic seamlessly: Capture all API traffic in an existing environment using a service-mes

Jan 1, 2023
Nba-simulation - Golang will be simulating nba match and streaming it real time

NBA Simulation golang in-memory To build and run go build ./nbaSimulation To ru

Feb 21, 2022
Openshift's hpessa-exporter allows users to export SMART information of local storage devices as Prometheus metrics, by using HPE Smart Storage Administrator tool

hpessa-exporter Overview Openshift's hpessa-exporter allows users to export SMART information of local storage devices as Prometheus metrics, by using

Jan 17, 2022
Taina backend Backend service With Golang

taina-backend Backend service Getting Started Essential steps to get your backend service deployed A helloworld example has been shipped with the temp

Nov 17, 2021
Acropolis Backend is the Go backend for Acropolis - the central management system for Full Stack at Brown
Acropolis Backend is the Go backend for Acropolis - the central management system for Full Stack at Brown

Acropolis Backend Acropolis Backend is the Go backend for Acropolis — the centra

Dec 25, 2021
Go-backend-test - Creating backend stuff & openid connect authentication stuff in golang

Go Backend Coding Practice This is my practice repo to learn about creating back

Feb 5, 2022
Oct 7, 2022
A component for sync services between Nacos and Kubernetes.

简介 该项目用于同步Kubernetes和Nacos之间的服务信息。 目前该项目仅支持 Kubernetes Service -> Nacos Service 的同步 TODO 增加高性能zap的logger 增加 Nacos Service -> Kubernetes Service 的同步 监听

May 16, 2022
The Oracle Database Operator for Kubernetes (a.k.a. OraOperator) helps developers, DBAs, DevOps and GitOps teams reduce the time and complexity of deploying and managing Oracle Databases

The Oracle Database Operator for Kubernetes (a.k.a. OraOperator) helps developers, DBAs, DevOps and GitOps teams reduce the time and complexity of deploying and managing Oracle Databases. It eliminates the dependency on a human operator or administrator for the majority of database operations.

Dec 14, 2022
KEDA is a Kubernetes-based Event Driven Autoscaling component. It provides event driven scale for any container running in Kubernetes
 KEDA is a Kubernetes-based Event Driven Autoscaling component. It provides event driven scale for any container running in Kubernetes

Kubernetes-based Event Driven Autoscaling KEDA allows for fine-grained autoscaling (including to/from zero) for event driven Kubernetes workloads. KED

Jan 7, 2023
A Pulumi Kubernetes CertManager component

Pulumi Cert Manager Component This repo contains the Pulumi Cert Manager component for Kubernetes. This add-on automates the management and issuance o

Nov 30, 2022
A Pulumi Kubernetes CoreDNS component

Pulumi Kubernetes CoreDNS Component This repo contains the Pulumi CoreDNS component for Kubernetes. CoreDNS is a fast and flexible DNS server, providi

Dec 1, 2021
A Pulumi NGINX Ingress Controller component

Pulumi NGINX Ingress Controller Component This repo contains the Pulumi NGINX Ingress Controller component for Kubernetes. This ingress controller use

Aug 10, 2022