Quickstart in Universal Mode

    Kuma can run in both Kubernetes (Containers) and Universal mode (for VMs and Bare Metal). You are now looking at the quickstart for Universal mode, but you can also check out the .

    In order to simulate a real-world scenario, we have built a simple demo application that resembles a marketplace. In this tutorial we will:

    You can also access the Kuma marketplace demo repository to try more features and policies in addition to the ones described in this quickstart.

    Community Chat: If you need help, you can chat with the Community where you can ask questions, contribute back to Kuma and send feedback.

    First, must be installed on your machine.

    You then need to clone the demo repository which contains all necessary files to deploy the application with Vagrant:

    Once cloned, you will find the contents of universal demo in the folder. Enter the vagrant folder by running:

    1. $ cd kuma-demo/vagrant

    Next, to install the marketplace demo application you can run:

    1. $ vagrant up

    This will create virtual machines for each services required to run the application, in this case:

    • frontend: the entry-point service that serves the web application.
    • backend: the underlying backend component that powers the frontend service.
    • postgres: the database that stores the marketplace items.
    • redis: the backend storage for items reviews.

    You can then access the application by navigating to 192.168.33.70:8000 (opens new window).

    You can visualize the sidecars proxies that have connected to Kuma by running:

    You can navigate to to see the connected dataplanes.

    Kuma ships with a read-only HTTP API that you can use to retrieve Kuma resources.

    By default the HTTP API listens on port 5681.

    Navigate to 192.168.33.10:5681/meshes/default/dataplanes (opens new window) to see the connected dataplanes.

    You can use the kumactl CLI to perform read-only operations on Kuma resources. The kumactl binary is a client to the Kuma HTTP API, you will need to first port-forward the API service with:

    Run kumactl, for example:

    You can configure kumactl to point to any remote kuma-cp instance by running:

    1. $ kumactl config control-planes add --name=XYZ --address=http://{address-to-kuma}:5681

    By default the network is unsecure and not encrypted. We can change this with Kuma by enabling the policy to provision a dynamic Certificate Authority (CA) on the Mesh resource that will automatically assign TLS certificates to our services (more specifically to the injected dataplane proxies running alongside the services).

    We can enable Mutual TLS with a builtin CA backend by executing:

    1. type: Mesh
    2. name: default
    3. mtls:
    4.   enabledBackend: ca-1
    5.   backends:
    6.   - name: ca-1
    7.     type: builtin
    8. EOF

    Once Mutual TLS has been enabled, Kuma will not allow traffic to flow freely across our services unless we explicitly create a policy that describes what services can be consumed by other services. You can try to make requests to the demo application at 192.168.33.70:8000/Universal Quickstart - 图6 (opens new window) and you will notice that they will not work.

    In a live environment we suggest to setup the Traffic Permission policies prior to enabling Mutual TLS in order to avoid unexpected interruptions of the service-to-service traffic.

    By doing so every request we now make on our demo application at is not only working again, but it is automatically encrypted and secure.

    As usual, you can visualize the Mutual TLS configuration and the Traffic Permission policies we have just applied via the GUI, the HTTP API or kumactl.

    Among the many policies that Kuma provides out of the box, one of the most important ones is .

    With Traffic Metrics we can leverage Prometheus and Grafana to visualize powerful dashboards that show the overall traffic activity of our application and the status of the Service Mesh.

    1. $ cat <<EOF | kumactl apply -f -
    2. type: Mesh
    3. name: default
    4. mtls:
    5.   enabledBackend: ca-1
    7.     type: builtin
    8. metrics:
    9.   enabledBackend: prometheus-1
    10.   backends:
    11.   - name: prometheus-1
    12.     type: prometheus
    13.     conf:
    14.       skipMTLS: true
    15. EOF

    This will enable the prometheus metrics backend on the default Mesh and automatically collect metrics for all of our traffic.

    Now let’s go ahead and generate some traffic - to populate our charts - by using the demo application!

    You can also generate some artificial traffic with the following command to save some clicks:

    1. while [ true ]; do curl http://192.168.33.70:8000/items?q=; curl http://192.168.33.70:8000/items/1/reviews; done

    And then access the Grafana dashboard at with default credentials for both the username (admin) and the password (admin).

    Kuma automatically installs three dashboard that are ready to use:

    • Kuma Mesh: to visualize the status of the overall Mesh.
    • Kuma Dataplane: to visualize metrics for a single individual dataplane.
    • Kuma Service to Service: to visualize traffic metrics for our services.

    You can now explore the dashboards and see the metrics being populated over time.

    Next steps

    Protip: Use on Twitter to chat about Kuma.

    • Explore the available to govern and orchestrate your service traffic.
    • Chat with us at the official Kuma Slack for questions or feedback.