Shipa Blog

Latest updates on our products, plus helpful articles relating to Kubernetes, container security, microservices and more

DigitalOcean and the developer experience for Kubernetes

TL;DR

  • Even though DigitalOcean has great mind-share with developers, the managed Kubernetes offering (DOKS) does not offer a developer-friendly way to consume it.
  • By combining Shipa and DOKS, developers and DevOps can quickly adopt DOKS and deploy, manage, and secure their applications on Kubernetes.
  • Both solutions together create a complete workflow and enable DigitalOcean to tap into the user’s existing stack.

Background

DigitalOcean, or DO, brands itself as the “developer cloud,” and it’s no secret that it has a strong mind-share among developers, especially because of factors such as simple UI, performance, structured documentation, a robust community ecosystem, and last but not least, the affordable pricing.

As developers started adopting microservices as the architecture of choice for their applications, DO responded quickly and launched their Managed Kubernetes offering, labeled DOKS.

The managed offering is marketed as a platform designed to allow you to start quickly, scale easily, and launch your applications fast. Those are all critical points for the market DO focuses on, small to medium-sized companies, generally.

With the above in mind, I took DOKS for a spin. The interface was indeed easy to navigate, creating a cluster was extremely easy, and connecting my terminal to my cluster was a breeze. As always, DO’s documentation was on point.

But once I had my kubectl configured, questions started to arise:

  • As a DevOps on a small to mid-sized organization, where do I go from now? My users (developers) will need monitoring and observability, and I need to enforce policies on what’s deployed, I need to onboard my developers fast, and more. 
  • It’s no secret that developers are not the biggest Kubernetes fans (I know I will get heat from Kubernetes die-hard fans here). The goal is to deploy and manage applications in the easiest way possible. If that’s my goal, as a developer, how do I do this using DOKS?

From what I could gather, unless both DevOps and developers are very familiar and comfortable with Kubernetes, the DOKS offer is not much of a help here, which then gets in the way of delivering some of the promises and goals listed above.

But what if you could partner DOKS offering with an application or developer platform? This could give you the best DO has to offer, along with the capabilities you need to get up and running on Kubernetes (or DOKS) faster.

At an organizational level, this can also enable DO to get further traction in the Kubernetes space and allow their users and customers to increase utilization of the DOKS offering.

That’s where Shipa comes in.

Shipa is an application platform that helps software development teams deploy, manage, and secure applications in modern infrastructures, such as Kubernetes. Integrated with the DevOps toolchain, Shipa can enable developers and DevOps teams to quickly adopt DOKS while connecting it to their existing infrastructure and toolchain.

In the example below, we will show you how to get DOKS and Shipa connected, define a basic set of policies, and deploy an application. All without dealing with Kubernetes-related complexities.

Requirements

Getting it Done

Creating a Policy

Achieving the goals mentioned above will give you a complete workflow to address both DevOps and developers’ needs.

Your starting point is to create a policy framework:

Shipa uses policy frameworks to connect to your DOKS cluster and to enforce policies to applications deployed by developers. Once you are logged into your Shipa Cloud dashboard, you can click on Frameworks, on the left menu and then on the “Create Framework” option.

These policy frameworks enable you to define and enforce policies across networking, scalability, registry control, and more. To keep this simple, select “Deploy applications with reasonable defaults” and click on Next.

You can enter the policy name on the next screen and select the default values available for Plan and Teams.

Now click on Create.

Connecting to DOKS

You can now connect your policy framework to your DOKS cluster. Click on the Clusters option on your left menu and “Add Cluster”.

Here you can enter:

  • The name of the DOKS cluster 
  • The policy framework you created previously

Clicking on Next will show you the fields to enter the DOKS details that Shipa will need to connect to it:

You can find detailed instructions on how to get the information above here, or you can download and run this script, which will display the information above.

Once you enter the information, click on Next.

You don’t need to enter anything here since you are using a brand new DOKS cluster. Just click on Create.

Shipa will then:

  • Connect to your cluster
  • Create a namespace dedicated to the policy framework you are connecting to this cluster
  • Install and configure NGNIX to be used as the ingress for applications

The process above takes between 2 and 3 minutes as DOKS takes a while to provision the LoadBalancer.

Deploying an Application

With your policy created and connected to a DOKS cluster, you can now deploy an application. 

Just click on the Applications options in your left menu and “Create App”. Enter the name of the application, select the policy you created previously, the team available, and click on Create:

Here, you created an application and assigned it to a policy you created before. Click on the application name now to see the application details page.

On the top menu, you will see the deploy option. Click on it:

The Deploy option will show you the following:

Although you have different deployment options, just keep “Public registry” as the Deployment source and enter the following image name:

  • docker.io/shipasoftware/bulletinboard:1.0

By clicking on the Submit button, your deployment will start and finish in a few seconds. 

You will see that Shipa will automatically configure an endpoint for your application where you can access it. Beyond that, you can now see application performance, dependencies, setup service-to-service communication, and more without dealing with the underlying Kubernetes, or DOKS, complexities.

Conclusion

By combining both solutions, developers and DevOps teams can take advantage of all the benefits they love from DigitalOcean, rapidly adopt Kubernetes, deploy applications faster, and keep the focus and experience at the application level.

A combined solution also enables DigitalOcean to increase ease of adoption of their Kubernetes offering and leveraging Shipa’s connection into different tools such as ArgoCD, Terraform, Pulumi, and others to be at the center of their customer’s stack of choice.