Napptive as a self service kubernates platform

1. What is Napptive platform

NAPPTIVE is the open source platform that helps cloud-native application Deployment and Integrations in different cloud platform like GCP, Microsoft azure, docker, rancher etc. It also provide an integrated solution that can be used by any member of your organization including developers and non-technical users to deploy applications in modern infrastructures.

2. Why Napptive

Napptive is a fully open source platform.
Here you can easily manage & deploy your kubernates application.
Napptive can easily intergrate with various cloud provider such as GCP, Rancher, Docker, Microsoft azure.
This platform is fully extensible to radically accelerate the process of creating applications covering essential requirements.

3. How deployment works

As a demo purpose First, list the available applications and select the version to be deployed. Click on the upper left hand corner icon to list all the available applications.

For example select the drawio application in the napptive catalog namespace

next, select the tag to be deployed and click on the Deploy button at the top left. Finally, choose the target environment (at this moment you will only have one) and Deploy it!

After that, the application will appear in the main screen.

To open the application, click on the endpoint button in the application information.

And drawio will open in your browser

To remove the deployed application click Delete in the application info and confirm you are sure you want to delete it.

4. Deploying a custom application

Deploying applications in the NAPPTIVE playground can be done by two different methods: using the catalog as a specification repository or directly with the CLI with local files.

The first step is to create a YAML file with the Application to be deployed. For this example we will use a simple mono-component application to deploy Nginx. The application can be easily defined leveraging the webservice component type as we are interested in having a service for the deployed component, and the napptive-ingress trait to expose a public endpoint.

Copy the following application and save it in a YAML file named custom-app.yaml.

apiVersion: core.oam.dev/v1beta1
kind: Application
metadata:
  name: custom-app
  annotations: # include optional annotations and/or labels.
    version: v1.0.0
    description: "Customized version of nginx"
spec:
  components:
    - name: nginx # an nginx component exposing port 80
      type: webservice
      properties:
        image: nginx:1.20.0
        ports:
        - port: 80
          expose: true
      traits:
      - type: napptive-ingress # a napptive-ingress trait to get a public endpoint
        properties:
          name: nginx
          port: 80
          path: /

Now proceed with the deployment by first logging into the platform if you have not done so.

playground login

And now deploy your application with

playground apps create <path>/custom-app.yaml

Now check the status and open the public endpoint

playground apps info custom-app

and to open the endpoints:

playground apps open custom-app

Another method to deploy a custom application is to upload its specification first to the public catalog and then deploy from it using the same approach

For this example, we will use the same nginx application and it the first section with the addition of a metadata entity for the catalog. First, create a new folder named custom-app and copy the following files to it.

custom-app.yaml


apiVersion: core.oam.dev/v1beta1
kind: Application
metadata:
  name: custom-app
  annotations: # include optional annotations and/or labels.
    version: v1.0.0
    description: "Customized version of nginx"
spec:
  components:
    - name: nginx # an nginx component exposing port 80
      type: webservice
      properties:
        image: nginx:1.20.0
        ports:
        - port: 80
          expose: true
      traits:
      - type: napptive-ingress # a napptive-ingress trait to get a public endpoint
        properties:
          name: nginx
          port: 80
          path: /

custom-app-metadata.yaml


apiVersion: core.napptive.com/v1alpha1
kind: ApplicationMetadata
name: "My custom NGINX server"
version: 1.20.0
description: Example of a custom application
keywords: # Optional
  - "server"
license: "Apache License Version 2.0" # Optional
url: "https://www.nginx.com/" # Optional
doc: "http://nginx.org/" # Optional

and now, upload the application to the catalog using:

playground catalog push <your_user>/my-custom-app:v1.0 /path/to/custom-app

and deploy it with:

playground catalog deploy <your_user>/custom-app:v1.0

if you want to remove the application from the catalog use this command :

playground catalog remove <your_user>/custom-app:v1.0

5. Advantages

Reduce deadtime waiting for clusters to be available
Reduce time spent installing and managing one-use infrastructure for your team members
Stop reusing Kubernetes namespaces
Easy integration with CI/CD tools
Work with isolated environments to accommodate your workloads: testing, developing, staging or production workloads
Avoid reusing namespaces with the self-service provisioning capabilities