Netris raises $15M Series A from a16z to help AI neoclouds go live faster

Learn how to set up network switch configurations that accelerate cloud deployments, similar to what Netris provides for AI neoclouds.

Introduction

In today's fast-paced digital world, getting new cloud services up and running quickly is crucial for businesses. Netris, a company that helps network infrastructure operate more efficiently, has raised $15 million to help AI neoclouds (new cloud services) go live faster. In this tutorial, we'll explore how to work with network switch software that can help accelerate your cloud deployments.

This hands-on tutorial will teach you how to set up and configure a basic network switch simulation that mimics the kind of infrastructure Netris works with. You'll learn how to create network configurations that can be used to speed up cloud service deployments.

Prerequisites

Before starting this tutorial, you'll need:

A computer with internet access
Basic understanding of networking concepts (IP addresses, subnets, ports)
Python 3.6 or higher installed on your system
Access to a terminal or command prompt

No prior experience with Netris or specific network switch software is required - we'll build up the concepts from the ground up.

Step-by-Step Instructions

1. Install Required Python Packages

First, we need to install the Python packages that will help us simulate network switch behavior. Open your terminal and run:

pip install netaddr scapy

Why: The netaddr library helps us work with IP addresses and subnets, while scapy allows us to simulate network packets and interactions - both essential for understanding how network switches operate.

2. Create a Basic Network Configuration File

Let's create a simple configuration file that represents network settings for a cloud deployment:

import json

# Create network configuration
network_config = {
    "switch_name": "neocloud-switch-01",
    "management_ip": "192.168.1.100",
    "network_segments": [
        {
            "segment_name": "frontend",
            "subnet": "10.0.1.0/24",
            "gateway": "10.0.1.1"
        },
        {
            "segment_name": "backend",
            "subnet": "10.0.2.0/24",
            "gateway": "10.0.2.1"
        }
    ],
    "vlan_config": {
        "frontend_vlan": 101,
        "backend_vlan": 102
    }
}

# Save to file
with open('network_config.json', 'w') as f:
    json.dump(network_config, f, indent=4)

print("Network configuration saved to network_config.json")

Why: This configuration file represents how a network switch would be set up to support different cloud service segments, similar to what Netris helps automate.

3. Simulate Network Switch Operations

Now let's create a script that simulates how a network switch would process network traffic:

from netaddr import IPNetwork
from scapy.all import *
import json

# Load network configuration
with open('network_config.json', 'r') as f:
    config = json.load(f)

print(f"Initializing switch: {config['switch_name']}")
print(f"Management IP: {config['management_ip']}")

# Simulate network segments
for segment in config['network_segments']:
    network = IPNetwork(segment['subnet'])
    print(f"\nSegment: {segment['segment_name']}")
    print(f"Subnet: {segment['subnet']}")
    print(f"Gateway: {segment['gateway']}")
    print(f"Available IPs: {list(network.hosts())[:5]}...")  # Show first 5 IPs

Why: This simulates how a network switch would organize and manage different network segments, which is a key part of how Netris helps accelerate cloud deployments.

4. Create a Virtual Network Interface

Let's create a simple virtual interface that represents how network switches handle traffic:

import socket
import threading

# Function to simulate switch port handling
def handle_network_traffic(port, segment):
    print(f"\nHandling traffic on port {port} for {segment['segment_name']}")
    
    # Simulate packet processing
    for i in range(3):
        packet = {
            "source": f"10.0.{segment['segment_name'][-1]}.{i+1}",
            "destination": f"10.0.{segment['segment_name'][-1]}.10",
            "protocol": "TCP",
            "port": 80 + i
        }
        print(f"  Processing packet {i+1}: {packet}")
        
        # Simulate processing delay
        import time
        time.sleep(0.5)

# Simulate handling multiple segments
for segment in config['network_segments']:
    port = 1000 + int(segment['segment_name'][-1])
    thread = threading.Thread(target=handle_network_traffic, args=(port, segment))
    thread.start()

Why: This demonstrates how network switches handle traffic from different segments, similar to how Netris optimizes switch operations for faster cloud service delivery.

5. Test Switch Configuration

Let's create a final test script that validates our network configuration:

def validate_network_config(config):
    print("\nValidating network configuration...")
    
    # Check if management IP is valid
    try:
        ip = IPNetwork(config['management_ip'])
        print(f"✓ Management IP {config['management_ip']} is valid")
    except Exception as e:
        print(f"✗ Management IP invalid: {e}")
        
    # Validate each network segment
    for segment in config['network_segments']:
        try:
            network = IPNetwork(segment['subnet'])
            print(f"✓ Segment {segment['segment_name']} subnet {segment['subnet']} is valid")
            
            # Check if gateway is within subnet
            gateway_ip = IPNetwork(segment['gateway'] + '/32')
            if gateway_ip in network:
                print(f"  ✓ Gateway {segment['gateway']} is within subnet")
            else:
                print(f"  ✗ Gateway {segment['gateway']} is NOT within subnet")
                
        except Exception as e:
            print(f"✗ Segment {segment['segment_name']} validation failed: {e}")

# Run validation
validate_network_config(config)

Why: Validating configurations is crucial for ensuring that network switches work properly before deploying cloud services, which is exactly what Netris helps streamline.

6. Run the Complete Simulation

Finally, let's run our complete network switch simulation:

print("=== Netris-style Network Switch Simulation ===")
print("This simulates how Netris helps accelerate cloud deployments")

# Run all components
print("\n1. Loading configuration...")
# (Previous code would go here)

print("\n2. Initializing network segments...")
# (Previous code would go here)

print("\n3. Starting traffic handling...")
# (Previous code would go here)

print("\n4. Validating configuration...")
# (Previous code would go here)

print("\n=== Simulation Complete ===")
print("This demonstrates how network switch configurations can be automated")
print("to speed up cloud service deployments, similar to what Netris provides.")

Why: Running the complete simulation shows how network infrastructure can be configured and validated to support rapid cloud service deployment, which is the core value proposition of Netris.

Summary

In this tutorial, we've learned how to work with network switch configurations that are similar to what Netris provides. We created network configuration files, simulated switch operations, and validated network settings. While this is a simplified simulation, it demonstrates the core concepts of how network infrastructure can be optimized to accelerate cloud deployments.

Netris helps companies reduce the time it takes to go live with new cloud services by automating and optimizing network switch configurations. This tutorial gave you a hands-on introduction to the networking concepts that underlie that automation, providing a foundation for understanding how network infrastructure supports modern cloud services.