Deploy First Application

    Welcome to KubeVela! In this guide, we’ll walk you through how to install KubeVela, and deploy your first simple application.

    Make sure you have finished and verified KubeVela installation following this guide.

    A Simple Application

    A simple deployment definition in KubeVela looks as below:

    Now deploy it to KubeVela:

    This command will deploy a web service component to target environment, which in our case is the Kubernetes cluster that KubeVela itself is installed.

    After deployed, you can now directly visit this application as it already attached with a ingress trait (assume your cluster has Ingress enabled).

    You can also try:

    1. apiVersion: core.oam.dev/v1beta1
    2. kind: Application
    3. metadata:
    4.   name: app-delivering-chart
    5. spec:
    6.   components:
    7.     - name: redis-comp
    8.       type: helm
    9.       properties:
    10.         chart: redis-cluster
    11.         version: 6.2.7
    12.         url: https://charts.bitnami.com/bitnami
    13.         repoType: helm
    1. apiVersion: core.oam.dev/v1beta1
    2. kind: Application
    3. metadata:
    4.   name: git-app
    5. spec:
    6.   components:
    7.     - name: git-comp
    8.       type: kustomize
    9.       properties:
    10.         repoType: git
    11.         url: https://github.com/<path>/<to>/<repo>
    12.         git:
    13.           branch: master
    14.         path: ./app/dev/

    … and many many more. Please check the Deploying Components section under User Manuals for all supported types, and even go ahead to add your own.

    Attach Operational Behaviors

    KubeVela is not just about deploy. It allows you to attach predefined operational behaviors (named Traits) to your components in-place. For example, let’s assign a batch rollout strategy to our web service:

    Now whenever the image version is updated in above YAML file, the express-server component will rollout following strategy defined in rolloutBatches.

    For all supported traits in KubeVela, please check Attaching Traits section under User Manuals. Not surprisingly, you can also add your own traits to KubeVela with just minimal effort.

    Components and traits are just the beginning of your vela sail. KubeVela is by design a full functional Continuous Delivery (CD) platform with fine grained support for hybrid/multi-cloud/multi-cluster deployment.

    I want to deploy an micro-services application with two components, firstly to staging cluster with only 1 instance, then pause and wait for manual approval. If approved, then deploy it to production cluster but with instances scaled to 3.

    Oops, imagine how many add-hoc scripts and glue code are needed in your CI/CD pipeline to achieve automation and deployment success rate in above process.

    While with KubeVela, above process can be easily modeled as a declarative deployment plan as below:

    1. apiVersion: core.oam.dev/v1beta1
    3.   name: example-app
    4.   namespace: default
    5. spec:
    6.   components:
    7.     - name: hello-world-server
    8.       type: webservice
    9.       properties:
    10.         image: crccheck/hello-world
    11.         port: 8000
    12.       traits:
    13.         - type: scaler
    14.           properties:
    15.             replicas: 1
    16.     - name: data-worker
    17.       type: worker
    18.       properties:
    19.         image: busybox
    20.         cmd:
    21.           - sleep
    22.           - '1000000'
    23.   policies:
    24.     - name: example-multi-env-policy
    25.       type: env-binding
    26.       properties:
    27.         envs:
    28.           - name: staging
    29.             placement: # selecting the cluster to deploy to
    30.               clusterSelector:
    31.                 name: cluster-staging
    32.             selector: # selecting which component to use
    33.               components:
    34.                 - hello-world-server
    37.           - name: prod
    38.             placement:
    39.               clusterSelector:
    41.               components:
    42.                 - name: hello-world-server
    43.                   type: webservice
    44.                   traits:
    45.                     - type: scaler
    46.                       properties:
    47.                         replicas: 3
    50.     - name: health-policy-demo
    51.       type: health
    52.       properties:
    53.         probeInterval: 5
    54.         probeTimeout: 10
    57.   workflow:
    58.     steps:
    59.       # deploy to staging env
    60.       - name: deploy-staging
    61.         type: deploy2env
    62.         properties:
    63.           policy: example-multi-env-policy
    64.           env: staging
    67.       # manual check
    68.       - name: manual-approval
    69.         type: suspend
    72.       # deploy to prod env
    73.       - name: deploy-prod
    74.         type: deploy2env
    75.         properties:
    76.           policy: example-multi-env-policy
    77.           env: prod

    No more add-hoc scripts or glue code, KubeVela will get the application delivery workflow done with full automation and determinism. Most importantly, KubeVela expects you keep using the CI solutions you are already familiar with and KubeVela is fully complementary to them as the CD control plane.

    For using KubeVela with your own CI pipelines and other tools, please check Best Practices section in the sidebar for more real world examples.

    What’s Next

    All above features are just the first glance of KubeVela. For next steps, we recommend: