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 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.

    KubeVela allows you to deploy diverse components types. In above example, the Web Service component is actually a predefined module.

    You can also try:

    1. apiVersion: core.oam.dev/v1beta1
    3. kind: Application
    5. metadata:
    7.   name: app-delivering-chart
    9. spec:
    11.   components:
    13.     - name: redis-comp
    15.       type: helm
    17.       properties:
    19.         chart: redis-cluster
    21.         version: 6.2.7
    23.         url: https://charts.bitnami.com/bitnami
    25.         repoType: helm
    1. apiVersion: core.oam.dev/v1beta1
    3. kind: Application
    5. metadata:
    7.   name: git-app
    9. spec:
    11.   components:
    13.     - name: git-comp
    15.       type: kustomize
    17.       properties:
    19.         repoType: git
    21.         url: https://github.com/<path>/<to>/<repo>
    23.         git:
    25.           branch: master
    27.         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.

    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.

    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.

    Let’s say:

    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. kind: Application
    5. metadata:
    7.   name: example-app
    9.   namespace: default
    10. spec:
    12.   components:
    14.     - name: hello-world-server
    16.       type: webservice
    18.       properties:
    20.         image: crccheck/hello-world
    22.         port: 8000
    24.       traits:
    26.         - type: scaler
    28.           properties:
    30.             replicas: 1
    32.     - name: data-worker
    34.       type: worker
    36.       properties:
    38.         image: busybox
    40.         cmd:
    42.           - sleep
    44.           - '1000000'
    46.   policies:
    48.     - name: example-multi-env-policy
    50.       type: env-binding
    52.       properties:
    54.         envs:
    56.           - name: staging
    58.             placement: # selecting the cluster to deploy to
    60.               clusterSelector:
    62.                 name: cluster-staging
    64.             selector: # selecting which component to use
    66.               components:
    68.                 - hello-world-server
    73.           - name: prod
    75.             placement:
    77.               clusterSelector:
    79.                 name: cluster-prod
    80.             patch: # overlay patch on above components
    82.               components:
    84.                 - name: hello-world-server
    86.                   type: webservice
    88.                   traits:
    90.                     - type: scaler
    92.                       properties:
    94.                         replicas: 3
    99.     - name: health-policy-demo
    101.       type: health
    103.       properties:
    105.         probeInterval: 5
    107.         probeTimeout: 10
    112.   workflow:
    114.     steps:
    116.       # deploy to staging env
    118.       - name: deploy-staging
    120.         type: deploy2env
    122.         properties:
    124.           policy: example-multi-env-policy
    126.           env: staging
    131.       # manual check
    133.       - name: manual-approval
    135.         type: suspend
    140.       # deploy to prod env
    142.       - name: deploy-prod
    144.         type: deploy2env
    146.         properties:
    148.           policy: example-multi-env-policy

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