Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/anthonycorletti/astrobase
Create kubernetes clusters quickly on GCP, AWS, or Azure.
https://github.com/anthonycorletti/astrobase
astrobase aws azure fastapi google-cloud kubernetes multi-cloud python3 typer
Last synced: about 7 hours ago
JSON representation
Create kubernetes clusters quickly on GCP, AWS, or Azure.
- Host: GitHub
- URL: https://github.com/anthonycorletti/astrobase
- Owner: anthonycorletti
- License: apache-2.0
- Created: 2020-09-17T19:59:01.000Z (about 4 years ago)
- Default Branch: main
- Last Pushed: 2023-02-06T21:23:12.000Z (almost 2 years ago)
- Last Synced: 2024-10-26T23:55:56.614Z (13 days ago)
- Topics: astrobase, aws, azure, fastapi, google-cloud, kubernetes, multi-cloud, python3, typer
- Language: Python
- Homepage: https://astrobase.corletti.xyz
- Size: 3.94 MB
- Stars: 64
- Watchers: 3
- Forks: 2
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- Contributing: CONTRIBUTING.md
- License: LICENSE
- Code of conduct: .github/code_of_conduct.md
- Security: .github/security.md
Awesome Lists containing this project
- awesome-fastapi - Astrobase - Simple, fast, and secure deployments anywhere. (Projects / Open Source Projects)
- awesome-fastapi - Astrobase - Simple, fast, and secure deployments anywhere. (Projects / Open Source Projects)
README
Astrobase; Create kubernetes clusters quickly on GCP, AWS, or Azure.
---
**Documentation**: https://astrobase.corletti.xyz
**Source Code**: https://github.com/anthonycorletti/astrobase
**Twitter**: @astrobasecloud
---
Astrobase is best for developers who create and manage reproducible environments across cloud providers with Kubernetes.
The key features are:
* **API First**: Unlike most other infrastructure management tools, Astrobase is an API-First service; meaning you can write any client code you like to create your Kubernetes clusters.
* **Kubernetes First**: Astrobase only supports Kubernetes so you and your team can focus on streamlining the same application deployment story across any provider envrionment you might need to run your applications on.
* **Easy to use**: Cluster creation definitions are short and simple, and you don't have to spend hours learning a domain specific language or think about a new resource management lifecycle. Astrobase only does what cloud providers do.
* **Start simple**: Astrobase's simplest example takes about 5 minutes to complete.
* **Scale across clouds**: If you're using Astrobase, and shipping your software to customers that use different cloud providers, you can test your deployments seamlessly and take advantage of over **$300,000** in cloud provider credits while doing so.
## Requirements
Python 3.7+
Alternatively, you can run Astrobase as a [docker container](./tutorial/intro.md) incase you arent using python.
## Installation
```sh
pip install astrobasecloud
```
## A Quick Example
### The absolute minimum
Create a file `gke-cluster.yaml` that contains the following content.
```yaml
---
cluster:
name: astrobase-quickstart
provider: gcp
location: us-central1-c
node_pools:
- name: default
initial_node_count: 1
autoscaling:
enabled: true
min_node_count: 1
max_node_count: 3
```
Create a project on Google Cloud and link a billing account to the new project.
```sh
PROJECT_ID=ab-quickstart-$(date +%s)
gcloud projects create ab-quickstart-$(date +%s)
gcloud config set project $PROJECT_ID
```
### Deploy
Start the astrobase server in one terminal session
```sh
astrobase server
```
Create your first profile. A profile points your cli to a particular astrobase server.
```sh
astrobase profile create local --no-secure \
export ASTROBASE_PROFILE=local
```
In another session, setup your GCP project and deploy your cluster!
```sh
astrobase provider setup gcp \
--project-id $(gcloud config get-value project) \
--service-name "container.googleapis.com"
```
```sh
astrobase cluster gke create \
--project-id $(gcloud config get-value project) \
--file "gke-cluster.yaml"
```
Done!
Download your credentials and make a request to the cluster once it's in a ready state
```sh
gcloud container clusters \
get-credentials astrobase-quickstart \
--zone us-central1-c && \
kubectl get nodes
```
Now it's time to clean-up.
```sh
astrobase cluster gke delete \
--project-id $(gcloud config get-value project) \
--file "gke-cluster.yaml"
gcloud projects delete $PROJECT_ID
```
## Going Multi-Cloud
### Two clusters, different clouds
Let's see what it takes to deploy onto two environments using Astrobase. Let's use GCP and AWS for this example.
Create a file `gke-cluster.yaml` with:
```yaml
---
cluster:
name: astrobase-quickstart
provider: gcp
location: us-central1-c
node_pools:
- name: default
initial_node_count: 1
autoscaling:
enabled: true
min_node_count: 1
max_node_count: 3
```
Now create a file `eks-cluster.yaml` with:
```yaml
---
cluster:
name: astrobase-quickstart
provider: eks
region: us-east-1
nodegroups:
- nodegroupName: default
scalingConfig:
desiredSize: 1
minSize: 1
maxSize: 3
```
### Deploy
Start the astrobase server in one terminal session
```sh
astrobase server
```
In another session, setup your GCP project and deploy your cluster!
```sh
astrobase provider setup gcp \
--project-id $(gcloud config get-value project) \
--service-name "container.googleapis.com"
```
```sh
astrobase cluster gke create \
--project-id $(gcloud config get-value project) \
--file "gke-cluster.yaml"
```
Then deploy your AWS EKS cluster!
```sh
astrobase cluster eks create \
--kubernetes-control-plane-arn=$(aws iam list-roles | jq -r '.Roles[] | select(.RoleName == "AstrobaseEKSRole") | .Arn') \
--cluster-subnet-id=$(aws ec2 describe-subnets --query 'Subnets[].SubnetId[]' | jq -r '.[0]') \
--cluster-subnet-id=$(aws ec2 describe-subnets --query 'Subnets[].SubnetId[]' | jq -r '.[1]') \
--cluster-security-group-id=$(aws ec2 describe-security-groups --query 'SecurityGroups[].GroupId' | jq -r '.[0]') \
--nodegroup-noderole-mapping="default=$(aws iam list-roles | jq -r '.Roles[] | select(.RoleName == "AstrobaseEKSNodegroupRole") | .Arn')" \
--file "eks-cluster.yaml"
```
Deploying your EKS cluster requires a little extra setup. Checkout the [AWS user guide section](./tutorial/aws/intro) for more details.
Now it's time to clean-up.
```sh
astrobase cluster gke delete \
--project-id $(gcloud config get-value project) \
--file "gke-cluster.yaml"
```
```sh
astrobase cluster eks delete \
--kubernetes-control-plane-arn=$(aws iam list-roles | jq -r '.Roles[] | select(.RoleName == "AstrobaseEKSRole") | .Arn') \
--cluster-subnet-id=$(aws ec2 describe-subnets --query 'Subnets[].SubnetId[]' | jq -r '.[0]') \
--cluster-subnet-id=$(aws ec2 describe-subnets --query 'Subnets[].SubnetId[]' | jq -r '.[1]') \
--cluster-security-group-id=$(aws ec2 describe-security-groups --query 'SecurityGroups[].GroupId' | jq -r '.[0]') \
--nodegroup-noderole-mapping="default=$(aws iam list-roles | jq -r '.Roles[] | select(.RoleName == "AstrobaseEKSNodegroupRole") | .Arn')" \
--file "eks-cluster.yaml"
```
## Recap
In summary, Astrobase makes it incredibly simple to create multiple kubernetes environments in different cloud providers.
You don't have to learn a new language, you can extend the api if you need, deploy Astrobase into your cloud architecture, or simply run it locally.
For a more complete example including more features and detail, [continue reading the user guide](./tutorial/intro.md).
## License
This project is licensed under the [Apache 2.0 License](https://github.com/anthonycorletti/astrobase/blob/main/LICENSE).