The Shipa Developer Hub

Welcome to the Shipa developer hub. You'll find comprehensive guides and documentation to help you start working with Shipa as quickly as possible, as well as support if you get stuck. Let's jump right in!

Get Started    Changelog

Pool Management

As the central point for application deployment control, Pools can be managed in 2 different ways today, through a template yaml file or manual individual commands through Shipa's CLI.

Pool Templates

Pool templates allow users to create "landing pads" for their applications as pool templates allows them to group different configuration sets that will be automatically applied to any application deployed to that specific pool.

Users can leverage templates to create and update pools through the following commands:

shipa pool-add template.yaml
shipa pool-update template.yaml

Below is an example of a pool template file:

ShipaPool: pool1
Resources:
   General:
      Setup:
         Force: true
         Default: true
         Public: true
         Provisioner: shipa
      Plan:
         Name: plan1    
      Security: 
         Disable-scan: false
         Scan-Platform-Layers: true
         Ignore-components: 
            - busybox
            - bash
            - curl
            - dpkg
         Ignore-CVES: 
            - CVE-xxxx-xxxx
            - CVE-xxxx-xxxx 
      Access: 
         Append: 
            - team1
            - team2
            - teamX
         Blacklist:
            - team3
            - teamN
      Services:
         Append: 
            - service1
            - service2
            - serviceX
         Blacklist:
            - service3
            - serviceN
      Volumes: 
         -  Name: volume-X
            PlanName: kube1
            Option1: capacity=1Gi
            Option2: access-modes=ReadWriteOnce

         -  Name: volume-Y
            PlanName: kube1
            Option1: capacity=5Gi
            Option2: access-modes=ReadWriteOnce

         -  Name: volume-Z
            PlanName: kube1
            Option1: capacity=100Gi
            Option2: access-modes=ReadWriteOnce
      AppQuota: 
         Limit: 3
   ShipaNode:
      Drivers: 
         - amazonec2
         - google
      AutoScale: 
         MaxContainer: 0
         MaxMemory: 0
         ScaleDown: 1.33
         Rebalance: true

Flags:

Flag

Description

Default

Is the pool going to be the default pool for application deployment(when none is specified during app-create, this pool will be used)?

Public

Make pool public for all teams to consume.

Provisioner

Provisioners are either shipa or kubernetes. If Kubernetes clusters will be added to this pool, then kubernetes should be used, otherwise, it should be used shipa

Shipa nodes and Kuberrnetes clusters cannot coexist in the same pool

Plan

Plan which will be assigned to all applications when deployed tot this pool. The plan should have been previously created through the shipa plan-create command

Security

What type of security scan and exceptions, if any, should be performed/allowed on every application deployed using this pool

Access

Which teams should have access to the pool or their access revoked

Services

Which services can be leveraged by applications deployed to this pool

Volumes

Volumes that should be created and made available to applications deployed through this pool. Please note that volumes will be created and attached to the pool but will remain available until they are bound to an application

AppQuota

Maximum amount of units (containers) each application deployed through this pool can scale to

ShipaNode/Drivers

Which node/cloud providers can be attached to this pool. Please note this is only valid when the provisioner is set to shipa in the Provisioner section.

ShipaNode/AutoScale

Node autoscale rules for Shipa nodes only

Manually Adding Pools

In order to create a pool, users should use the Shipa pool-add command as shown below:

$ shipa pool-add <pool> [-p/--public] [-d/--default] [--provisioner <name>] [-f/--force]

Each Shipa node added using the node-add command, by default, belongs to a pool. Also, when creating new applications, a pool must be chosen and this means that all units of the created application will be spawned in nodes belonging to the chosen pool

Flags:

Flag

Description

-d, --default

(= not set) Marks the pool as the default one(when none is specified during app-create, this pool will be used)

-f, --force

(= false) Force overwrite default pool

-p, --public

(= false) Make pool public (all teams can use it)

--provisioner

(= "") Provisioner associated to the pool (empty for default shipa provisioner)

Manually Updating Pool Attributes

$ shipa pool-update <pool> [--public=true/false] [--default=true/false] [-f/--force]

Updates attributes for a specific pool.

Flags:

Flag

Description

--default

(= not set) Marks the pool as the default one(when none is specified during app-create, this pool will be used)

-f, --force

(= false) Force pool to be default.

--public

(= not set) Make pool public (all teams can use it)

Manually Adding Teams to Pools

After pools are created, users can use Shipa's pool-constraint-set to add teams to the pool that were just created:

$ shipa pool-constraint-set pool1 team team1 team2 --append

$ shipa pool-constraint-set pool2 team team3 --append

Listing Pools

Listing the available pools in Shipa can be done by executing the following:

$ shipa pool-list
+-------+-------------+
| Pools | Teams       |
+-------+-------------+
| pool1 | team1 team2 |
| pool2 | team3       |
+-------+-------------+

Removing Pools

Pools can be removed at any time in Shipa. In order to do so, users can leverage Shipa's pool-remove command:

$ shipa pool-remove pool1

Manually Removing Teams from Pools

Administrators can remove one or more teams from a pool using the Shipa's pool-constraint-set command:

$ shipa pool-constraint-set pool1 team team1 --blacklist

$ shipa pool-constraint-set pool1 team team1 team2 team3 --blacklist

Manually Removing Services from Pools

Shipa provides users with use external services that applications can consume globally. With that, users have databases, storage, queueing and other services readily available globally for their applications. For more information, visit the Services page of this documentation.

As part of the management, users can remove one or more services from a pool using the command shipa pool-constraint-set:

$ shipa pool-constraint-set <pool> service <service1> <service2> <serviceN> --blacklist

$ shipa pool-constraint-set dev_pool service mongo_prod mysql_prod --blacklist

Updated 5 months ago

Pool Management


Suggested Edits are limited on API Reference Pages

You can only suggest edits to Markdown body content, but not to the API spec.