It can be difficult to understand how different software compares to each other. In this section, we compare Shipa to other software.
Helm is a package manager for Kubernetes. Helm makes it easier to package, version, install and upgrade a set of YAML files comprising the necessary resources within Kubernetes to run an application.
Shipa, on the other hand, is a Developer Platform used to deploy and manage applications, providing a consistent workflow and policy engine on top of that.
Helm does not provide higher-level features such as logs, shell, policy management, developer dashboard, etc. In contrast, Shipa provides a consistent experience all the way from application deployment and management to policy enforcement.
Helm is Kubernetes-specific, while Shipa is cluster-agnostic and focuses at the application level instead.
Heroku, OpenShift, and Cloud Foundry are examples of Platform-as-a-Service (PaaS) offerings.
Although PaaS systems are full platforms that focus on helping you deploy applications faster, they impose many restrictions. Restrictions such as:
Language: restricting only certain language runtimes.
Underlying networking: where you cannot bring your own load balancer or networking rules in place to address specific scenarios in many cases.
Services: restricting you to only certain types of supporting services, such as specific databases and no native cloud services.
Infrastructure: PaaS systems, most of the time, are fully managed systems and/or do now allow you to run it on your infrastructure of choices, such as different clouds, clusters, and underlying infrastructure configuration.
Shipa allows you to have platform-like features without the constraints imposed by traditional PaaS. Shipa implements a consistent experience and workflow between development and operations that can be applied to your selected underlying infrastructure, cloud, and cluster, allowing you to choose the tools that best fit your business and application goals while implementing a structured and secure Developer Platform.
Kubernetes (K8s) is a popular open-source platform for running containerized applications.
Kubernetes provides native features for health checking, configuration, load balancing, storage, and more. Although powerful, Kubernetes is very infrastructure-focused and implements an object context when deploying and managing applications, so you are expected to learn, create, and manage these objects at scale when implementing Kubernetes in your organization.
Shipa is a Developer Platform that is complimentary to Kubernetes. Shipa makes it easier to adopt Kubernetes by implementing a Developer Platform on top of different Kubernetes clusters that allows you to give your developers a portal to deploy and manage their applications, implement policies and governance across multiple clusters, and a structured workflow to help bring an application context level rather than an object context level.
Shipa does not prevent the Kubernetes-specific features from being used, does not take over your cluster, or locks you down into a specific cluster provider or version.
Most organizations start by manually managing application deployment and management on Kubernetes through custom scripts or internal custom-built platforms. As the infrastructure, the number of applications, and users grow, any manual approach to management becomes error-prone, tedious, and expensive.
These custom-built scripts and internal platforms require time and resources to build and maintain. As tools of necessity, they represent the minimum viable features needed by an organization, usually built to handle only the immediate needs. As a result, they are often hard to extend and difficult to maintain. Because the tooling must be updated in lockstep with any new features or infrastructure, it becomes the limiting factor for how quickly the infrastructure can evolve.
Shipa is designed to tackle these challenges. It provides a structured Developer Platform that allows you to get value through its developer portal, policy engine quickly, and structured workflow, removing the burden of building the internal tools and custom scripts, freeing up operations to focus on governance and developers on application deployment and management.
Shipa helps solve a growing problem for every organization that is adopting or scaling a microservice architecture and provides a standard that can be adopted to avoid reinventing the wheel between and within organizations.
Updated almost 2 years ago