These 3 concepts are:
1. Runtime automation
2. Data-driven Automation
3. Intent-based Orchestration
1. Runtime Automation
Imagine you have an engine that lets you configure any number of network devices (switch, router, firewall, API, EMS, controller, etc.) from any vendor, from one central place and for an endless variety of jobs. Pretty neat huh? No imagine that it can also handle checks, validations, conditions, backups and logging in a smart and automated way. This is exactly what the NetYCE engine does. Fully GUI based and with support for 20+ different network vendors, such as Cisco, Juniper, HP, Ciena, Huawei, Checkpoint, Fortinet, Palo Alto and many more.
Forget about manually logging into network devices or building and maintaining Python- or Ansible scripts. You only need to focus on what you want to achieve. Simply create or import your nodes and start building and deploying automated jobs. You can use parameterisation, templates, conditionals and functions to deal with any of your daily jobs. Then save & share them with others and schedule backups of all your node configs to keep control of what changes in production.
This powerful engine alone will solve most of your daily automation needs. It is part of the free NetYCE license and serves as the foundation for all other solutions explained below.
2. Data-driven Automation
Now let’s go one step further and truly boost your automation capabilities. Imagine you can automatically build jobs and configurations by combining different data sources with this runtime engine. You can use data from the internal database, your production network or from external sources (via the API).
First, the integrated, object-oriented YCE database lets you store any kind of information specific to your design or ‘snowflake’ network, in a relational- and vendor-agnostic way. This means you can store things like topology, ports, VRFs, IP plans, subnets, services and much more in one place. And then use them seamlessly with the netYCE engine and smart templates to generate data-driven jobs and configurations. Forget about using Excel and notepad or remembering everything from memory. Simply create and modify services by updating the database and generate configs & jobs that you want provisioned to your network with just a single mouse click or API call.
Second, imagine you can simply retrieve state information from your network devices and use it dynamically in your jobs. This is what 'command parsing' scenarios are all about. It lets you send show commands to your network devices and parse the requested information. The results can either be stored in the YCE database or used in real-time as input for your data-driven jobs. It gets even better when you learn more about 'scenarios'. These data-driven 'scripts' allow you to build extremely powerful run-books with automated rules, validations and process steps for every job you send to your network.
Third, data can also come from external systems (e.g. OSS/NMS) or from an Excel/CSV file. This can be sent to the netYCE API and processed as you like. You will be amazed by all the possibilities as anything that is possible via the GUI can also be done using the API. Updating your inventory, creating new services or simply invoking the API to send data-driven jobs to your network is easy as pie.
3. Intent-Based Orchestration
By now you have the ability to generate and deploy data-driven jobs and configs to any of your devices. This is extremely powerful, but it does not solve the risk of spinning out of control when you allow 'random' design choices during implementation. This is the major factor causing networks to become inflexible, unstable and unnecessarily difficult to automate. In order to maximise your potential benefits, this needs to be resolved. Therefore, you want to be able to model and standardise your network services and changes. And enforce your design rules into every job, configuration and process you build. And all without losing any flexibility as described before.
This is what 'design modelling' is all about. It allows you to build your own network design and service models that can generate standardised (blueprinted) services, jobs and configurations and robotise your changes.
What this means is that every change you now send to your network is built ‘as-designed' (as-intended) in the netYCE database first. No more errors as both the data, the jobs, the configs AND all process steps are now being generated and executed according to the design logic matching your business requirements.
Now you only need to ensure that these jobs get deployed without interfering with any existing service in your network. This is done by using command parsing. Realtime state information is then validated at runtime to guarantee that existing services aren't overwritten.
The 3 building blocks are extremely powerful and can be used standalone, but the true power lies in combining them. You can build any network automation solution you want as the possibilities are endless.
For example, you can enable zero-touch provisioning for any of your devices, delegate standard jobs to your internal users (self-service) or build closed-loop automations with NMS or AI systems. You can even configure NetYCE to be your 'über' orchestrator between 3rd party systems or combine existing Python or Ansible scripts to get really smart.
And the best part? Everything can be configured and built via a GUI that is designed for network engineers. NO coding in complex programming languages. At least not if you don’t want to, because the NetYCE engine will ‘eat’ any syntax, so if you prefer going more advanced by using netconf, Yaml, Json or any other new syntax, you can do that as well. Simply translate your existing network engineering knowledge in templates, models, scenarios and data-driven jobs, and start automating. It’s literally that simple. So what are you waiting for?
Want to know more?
Our #1 priority is helping you in your automation journey. To do that effectively, we’ve created this exclusive webinar where Pieter, one of our network engineers, will show you how to build a series of typical use cases.