Infrastructure as Code. It shouldn’t be this hard.

[ Edit – This is the second post in a two part series. The first one is here. ]

Tuono has removed the complexity from Infrastructure as Code. We have created the Tuono Intent Engine to deliver intent based infrastructure in the public cloud.

Conceptual image showing the easy and the hard way

The concept of “intent based” has historically been associated with networking, but why not apply it more generally to public cloud infrastructure? The goal of intent based infrastructure is to separate the high level what that the user is seeking from the details of how it is implemented and then automating the how to define and build the required components. Tuono users simply declare what infrastructure they want and the Tuono Intent Engine transforms the what into the how and automatically builds the desired architecture in the public cloud. (We also manage changes to the infrastructure over time and allow it to be easily removed, but that is a topic for a future article.)

Let’s take a look at a sample Tuono blueprint. The blueprint is the what that the user wants to set up. This sample declares a network, two subnets, two protocols, a basic firewall rule, a boot image, and three instances.

location:
  region:
    intent_region:
      country: USA
      area: northwest
  folder:
    intent_folder:
      region: intent_region
      name: Intent_RG
      
networking:
  network:
    intent_vnet:
      range:
        - 10.50.0.0/16
        - 10.150.0.0/16
      public: true
      enable_ipv6: true

  subnet:
    public_subnet:
      range: 10.50.0.0/16
      network: intent_vnet
      public: true
      firewall: management-access
    private_subnet:
      range: 10.150.0.0/16
      network: intent_vnet
      enable_ipv6: true
      isolated: false

  protocol:
    ssh:
      ports:
        - port: 22
          proto: tcp
    https:
      ports:
        - port: 443
          proto: tcp

  firewall:
    management-access:
      rules:
        - protocols:
            - https
            - ssh
          to: members
          from: 192.168.1.42

compute:
  image:
    bionic:
      publisher: Canonical
      product: UbuntuServer
      sku: 18.04-LTS
      venue:
        aws:
          image_id: ami-0a7d051a1c4b54f65

  vm:
    vm-instance:
      count: 3
      admin_username: adminuser
      cores: 2
      memory: 4 GB
      disks:
        data:
          size: 100GB
      image: bionic
      nics:
        external_nic:
          ips:
            - private:
                type: dynamic
              public:
                type: static
          firewall: management-access
          subnet: public_subnet
        internal_nic:
          ips:
            - private:
                type: dynamic
          subnet: private_subnet
      ssh_public_key: {{ public_key }}

We transform the what into the how and automatically create the required infrastructure in the cloud when we apply this Tuono blueprint to AWS. The transformation includes resolving all the AWS objects required, calculating all the object dependencies, analyzing what exists in AWS, creating/updating/deleting the AWS objects as needed, and managing the errors, timeouts, events, and delays from the eventually consistent control plane in AWS.

Let’s use the AWS console to take a look at the infrastructure Tuono creates…

Amazon Web Services EC2 screenshot showing objects created by Tuono Intent Engine. Infrastructure as Code
Amazon Web Services (AWS) EC2 Console

Tuono automatically creates 40 AWS objects and executes 703 calls to the AWS API. We create:

  • 1 x VPC
  • 2 x Subnets
  • 3 x Route Tables
  • 1 x Internet Gateway
  • 1 x Egress-only Internet Gateway
  • 4 x Elastic IPs
  • 1 x NAT Gateway
  • 4 x Network ACLs
  • 4 x Security Groups
  • 3 x Running Instances
  • 3 x Key Pairs
  • 6 x Volumes
  • 7 x Network Interfaces.

These AWS objects combine to deliver the functionality declared in the Tuono blueprint. This is what we are talking about when we say we deliver Infrastructure as Code with less code, less time, and less complexity. Without Tuono, each of these steps would need to be completed manually through the AWS console or code would need to be written to automate each detail.

In the words of Steve Jobs… There is “one more thing.” The same Tuono blueprint can be deployed to either AWS or Azure with no changes. The sample above declares your Infrastructure as Code in a single intent based blueprint and you can deploy it to either AWS or Azure. The object models and APIs for the clouds are completely different, but Tuono manages this so you don’t have to think about it.

If you apply the blueprint above to Azure, the Tuono Intent Engine will transform the what into the how and automatically create the required infrastructure in Azure. The blueprint creates 23 Azure objects, and 309 calls to the Azure API.

Azure Console screenshot showing objects created by Tuono Intent Engine. Infrastructure as Code
Microsoft Azure Console

Intent based Infrastructure as Code is about declaring what infrastructure is desired and leveraging a technology platform to figure out how to build it and automate the process of creating the required resources. In short, you define what you want to build and Tuono builds it for you. It’s that simple.

You can check out a demo of the Tuono platform here

Sign up for our newsletter


Close

Contact Us

Schedule a Demo

Request Early Access