Automatically scale hardware and easily run stateful applications using Kubernetes.
TypeScript Go CSS HTML Smarty Shell Other
stgleb and egopher Tasks framework MVP (#583)
* Create task framework

* Split node task in two separete rask for kubeproxy and kubelet

* Rename tests

* Remove node task

* Split scripts to more granular by their purpose

* Remove master obsolete master provision script

* Add tiller task

* Add task for CNI

* Update scripts

* Add write certificates task

* Add write kubelet conf task

* Add post start task

* Add  task for manifest

* Add systemd update task

* Add task interface
Add workflow type

* Rename systemd to kubelet systemd
Remove redundant code from post start script

* Move steps to workflow package

* Change step signature and fix tests

* Fix error in workflow steps slicce

* Merge step configs  to the single one

* Use single struct config to pass config values through interfaces

* Make central config for all steps

* Fix cicrcular dependency in workflow package

* Fix imports in workflow package

* More fix on circular deps

* Fix import erroors

* Fix build

* ultimate fix

* Fix import for certificates task

* Add constant task names for steps

* Change const name

* Change step interface

* Add ability to synchronize workflow

* Pass output writer to Run function

* make digital ocean task more reusable

* Move ssh runner to task config

* Fix CI build

* Add etcd for sync

* Add context to workflow and synchronizer

* Add restart method description

* Add tests for workflows

* Add fake task type for tests

* Add tests

* Use storage.Interface for storing state

* Add restart method and cover it with test

* Remove syncronizer

* Add handler for serving workflows endpoint

* Remove redundant params from constructor

* Add one workflow with steps

* Add docker task

* small formating

* Add centralazed step registry

* Add godoc and change builder function for workflow

* Add api endpoint for creating and running workflow

* Return newly created workflow id

* Add unit tests for build workflow method

* Separate workkflow type and task type

* Fix handlers tests and make them more testable

* Add mock steps for handler tests

* work on handler tests

* fix review issues

* reorder steps and add todo

* rename consts for cloud providers

* change error messages and protect map with lock

* Fix name collision

* Fix conflicts

* Add API endpoint for running existing workflow

* goimports workflow module

* Fix format string

* Add registering func and register task handler to protected API

* Add ability to get cloud account credentials from storage

* Add tests for filling credentials data

* add fill cloud account in handler

* Fix Run task test

* Add tags for config

* omit runner field in config

* Create example config, work on reassembling config and avoiding name conflicts

* Add download k8s binary step

* Add download k8s binary task
Extract all config objects to fields in json

* Update tests and config example

* Update comments

* Update steps and config.json

* fix kubeproxy and manifest tests

* Remove debug print

* Fix systemd tests

* Add cloud account service to task handler

* Creating droplet works

* Change step interface to update config

* fix digital ocean step

* Fix function call

* something works, flannel fails

* update flannel version

* rename docker template file

* Change step order and add todo

* Update on k8s version var name

* Rearrange names of templates and packages

* remove secret info

* Fix templates for docker step and add logging

* rearrange working steps

* fix kubelet_systemd template

* update k8s version

* update manifest

* fix tests

* etcd works, fix manifest

* flannel works, tiller work in progress

* add kubelet worker config to write manifest step

* reoder steps

* fix unit tests

* fix kubelet and manifest tempaltes

* fix kubeproxy template

* kubelet starts sucessfully

* Update manifest config

* Change write certificates step

* all services are started

* Change poststart

* update config.json

* update digital ocean step

* Fix kubeproxy test

* Use kubelet to start proxy on node instead of docker

* get rid of kube proxy template in favor of single manifest writing template

* Add error logging to workflow

* update workflow and etcd

* Make all steps get master ip from config

* increase ssh timeout

* Add timeout for droplet to become really operable

* gofmt and goimports

* fix build fail

* fix imports and cmd param

* fix unit tests

* Add dependency map for steps

* Add restart functionality for task

* Add retry to ssh and add new step state executing

* Add separate step for ssh

* Add todo for ssh key management

* gofmt workflow package

* Change example config

* Add timeout for poststart task

* Fix tests

* change template dir default path

* Fix wrong error for poststart

* fix ssh test

* update according to review

* handle template intializing error

* handle error when deserialize task

* update id to upper case
Latest commit fe875b9 Aug 14, 2018

README.md

Supergiant: Kubernetes Orchestration

Release Widget GoDoc Widget Travis Widget Coverage Status Widget GoReportCard Widget


Supergiant empowers developers and administrators through its simplified deployment and management of Kubernetes, in addition to easing the configuration and deployment of Helm charts, taking advantage of Kubernetes' power, flexibility, and abstraction.

Supergiant facilitates clusters on multiple cloud providers, striving for truly agnostic and impartial infrastructure--and it does this with an autoscaling system that cares deeply about efficiency. It asserts through downscaling and resource compaction that unutilized infrastructure shouldn't be paid for (and, therefore, shouldn't be running).

Supergiant implements simple practices that abstract load-balancing, application deployment, basic monitoring, node deployment or destruction, and more, on a highly usable UI. Its efficient compaction algorithm enables seamless auto-scaling of Kubernetes clusters, minimizing costs while maintaining the resiliency of applications. To dive into top-level concepts, see the documentation.

Features

  • Fully compatible with native Kubernetes versions 1.5.7, 1.6.7, 1.7.7, and 1.8.7
  • Easy management and deployment of multiple kubes in various configurations
  • AWS, DigitalOcean, OpenStack, Packet, GCE, and on-premise kube deployment
  • Easy creation of Helm releases, Pods, Services, LoadBalancers, etc.
  • Automatic, resource-based node scaling
  • Compatibility with multiple hardware architectures
  • Role-based Users, Session-based logins, self-signed SSLs, and API tokens
  • A clean UI and CLI, both built on top of an API (with importable Go client lib)

Resources

Community and Contributing

We are grateful for any contribution to the Supergiant project, be it in the form of a GitHub issue, a Pull Request, or any social media engagement. Contributing to Supergiant requires familiarization with the Community and Contribution Guidelines. Please see these links to get started:

Development

Setup

Note: These instructions are for setting up a local or custom environment and assume a "beginner" level of experience. For executable binaries, see the Releases Page. Before submitting a Pull Request, please see Community and Contributing above.

1. Install Dependencies:

Note: If a new package is imported and then used in Supergiant code, make sure to vendor the imports (the govendor binary is located in $GOPATH/bin/govendor):

govendor add +external

Note: New to any of these technologies? Here are a few basic, free resources:

2. Fork the Repo

Please make sure to fork the Supergiant project before getting started. Direct Pull Requests will not be accepted into the project.

To make the commands in subsequent steps copy-pastable, feel free to do the folowing:

GITHUB_USERNAME="github_username"

3. Clone the Fork

Clone the repo into a local Go project directory, and add an upstream remote to keep the fork synced:

git clone https://github.com/$GITHUB_USERNAME/supergiant.git $GOPATH/src/github.com/supergiant/supergiant
git remote add upstream https://github.com/supergiant/supergiant.git

Remember to checkout a branch to work on, or create a new branch.

4. Setup a Config File

Note: From now on, all specified directories have a root of $GOPATH/src/github.com/supergiant/.

Copy the example configuration from within ./supergiant/, or create a custom one as desired:

cp config/config.json.example config/config.json

5. Compile UI Assets

Run this from within ./supergiant/. It was once used to run the old UI, and, although the old UI is no longer in use, it is necessary to run the backend (the binary for go-bindata is found in $GOPATH/bin/):

go-bindata -pkg bindata -o bindata/bindata.go config/providers/... ui/assets/... ui/views/...

Operation

1. Running the Backend

From within ./supergiant/, run:

go run cmd/server/server.go --config-file config/config.json

The server will output as seen below:

INFO[0000] No Admin detected, creating new and printing credentials:

  ( ͡° ͜ʖ ͡°)  USERNAME: admin  PASSWORD: 0GYB4rIU8TaokNtJ

Note: The initial account login credentials will appear like this the first time that the server runs, and will not appear again, though anyone with access to these logs can see them. The credentials can be changed.

2. Running the UI

Currently, Supergiant uses a UI developed with Angular 5 and higher. The Angular project directory is found in ./supergiant/cmd/ui/assets. The old UI is accessible on port 8080 when the Supergiant Server is running.

2.a. Install Node Modules

In ./supergiant/cmd/ui/assets, run:

npm install

Note: If the UI fails to initialize, package and dependency problems are often the cause. If there is a problem with the project's current package.json or package-lock.json, please open a GitHub issue.

2.b. Serve the UI

Within ./supergiant/cmd/ui/assets/, run:

ng serve

The UI will be accessible on port 4200 by default. The server must be running to interact properly with the UI.

Building

1. Building the Server

Note: The build processes for both the server binary and Docker image are currently under review.

2. Building the UI

Run ng build to build the project. The build artifacts will be stored in the dist/ directory. Use the -prod flag for a production build.

Note: The build processes for both the UI binary and Docker image are currently under review.

Testing

1. Testing the Server

Currently, tests are split up into two groups: unit tests and integration tests. Unit tests are in ./supergiant/pkg/, and integration tests are in ./supergiant/test.

1.a. Unit Testing

To run unit tests, simply run go test on all of the Supergiant-specific packages within ./supergiant/:

go test -v ./pkg/...
1.b. Integration Testing

Note: Before running integration tests, make sure to set the required environment variables noted in the code for each provider in ./supergiant/test/providers/

For integration tests, Golang build tags are used. This helps with separation of testing concerns. The tag used is // +build integration. Like unit tests, it is easy to run the tests from ./supergiant/:

go test -v -tags=integration ./test/...

2. Testing the UI

1.a. Unit Testing

Run ng test to execute the unit tests with Karma.

1.b. E2E Testing

Run ng e2e to execute the end-to-end tests with Protractor. Before running the tests, make sure to serve the app via ng serve.

License

Copyright 2016 Qbox, Inc., a Delaware corporation. All rights reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.