Модель OSI

<?php

declare(strict_types=1);

/**
 * Demonstrating encapsulation concept.
 * Each layer adds metadata (headers) to the payload.
 */
final class PacketAnalyzer
{
    /**
     * Simulate packet structure at each OSI layer.
     * Useful for understanding what happens when PHP makes an HTTP request.
     *
     * @return array<string, array{header_size: int, description: string}>
     */
    public static function analyzeHttpPacket(): array
    {
        return [
            'L7_Application' => [
                'header_size' => 200,  // HTTP headers (Host, Content-Type, etc.)
                'description' => 'HTTP request: GET /api/users HTTP/1.1',
            ],
            'L6_Presentation' => [
                'header_size' => 40,   // TLS record header + encryption overhead
                'description' => 'TLS 1.3 encryption wrapper',
            ],
            'L4_Transport' => [
                'header_size' => 20,   // TCP header (src/dst port, seq, ack, flags)
                'description' => 'TCP segment: src_port=49152, dst_port=443',
            ],
            'L3_Network' => [
                'header_size' => 20,   // IP header (src/dst IP, TTL, protocol)
                'description' => 'IP packet: src=192.168.1.10, dst=93.184.216.34',
            ],
            'L2_DataLink' => [
                'header_size' => 18,   // Ethernet header (src/dst MAC) + FCS
                'description' => 'Ethernet frame: src_mac=AA:BB:CC:DD:EE:FF',
            ],
        ];
    }

    /**
     * Calculate overhead of network headers.
     * Important for understanding MTU and fragmentation.
     *
     * @param int $payloadBytes Application data size
     * @return array{total_bytes: int, overhead_percent: float}
     */
    public static function calculateOverhead(int $payloadBytes): array
    {
        // Typical header sizes
        $ethernetHeader = 14 + 4;     // 14 header + 4 FCS
        $ipHeader = 20;               // without options
        $tcpHeader = 20;              // without options
        $tlsRecord = 5 + 16 + 16;    // record header + IV + auth tag

        $totalOverhead = $ethernetHeader + $ipHeader + $tcpHeader + $tlsRecord;
        $totalBytes = $payloadBytes + $totalOverhead;

        return [
            'payload_bytes' => $payloadBytes,
            'overhead_bytes' => $totalOverhead,
            'total_bytes' => $totalBytes,
            'overhead_percent' => round(($totalOverhead / $totalBytes) * 100, 1),
        ];
    }
}

// Small payload: high relative overhead
$small = PacketAnalyzer::calculateOverhead(64);
// overhead: ~55% (for 64-byte payload, headers dominate)

// Large payload: low relative overhead
$large = PacketAnalyzer::calculateOverhead(1400);
// overhead: ~5% (for 1400-byte payload near MTU)

package network

import "math"

// LayerInfo describes a single OSI layer header.
type LayerInfo struct {
	HeaderSize  int
	Description string
}

// AnalyzeHTTPPacket simulates packet structure at each OSI layer.
func AnalyzeHTTPPacket() map[string]LayerInfo {
	return map[string]LayerInfo{
		"L7_Application": {
			HeaderSize:  200, // HTTP headers (Host, Content-Type, etc.)
			Description: "HTTP request: GET /api/users HTTP/1.1",
		},
		"L6_Presentation": {
			HeaderSize:  40, // TLS record header + encryption overhead
			Description: "TLS 1.3 encryption wrapper",
		},
		"L4_Transport": {
			HeaderSize:  20, // TCP header (src/dst port, seq, ack, flags)
			Description: "TCP segment: src_port=49152, dst_port=443",
		},
		"L3_Network": {
			HeaderSize:  20, // IP header (src/dst IP, TTL, protocol)
			Description: "IP packet: src=192.168.1.10, dst=93.184.216.34",
		},
		"L2_DataLink": {
			HeaderSize:  18, // Ethernet header (src/dst MAC) + FCS
			Description: "Ethernet frame: src_mac=AA:BB:CC:DD:EE:FF",
		},
	}
}

// OverheadResult holds the result of overhead calculation.
type OverheadResult struct {
	PayloadBytes    int
	OverheadBytes   int
	TotalBytes      int
	OverheadPercent float64
}

// CalculateOverhead computes network header overhead for a given payload size.
func CalculateOverhead(payloadBytes int) OverheadResult {
	const (
		ethernetHeader = 14 + 4   // 14 header + 4 FCS
		ipHeader       = 20       // without options
		tcpHeader      = 20       // without options
		tlsRecord      = 5 + 16 + 16 // record header + IV + auth tag
	)

	totalOverhead := ethernetHeader + ipHeader + tcpHeader + tlsRecord
	totalBytes := payloadBytes + totalOverhead

	return OverheadResult{
		PayloadBytes:    payloadBytes,
		OverheadBytes:   totalOverhead,
		TotalBytes:      totalBytes,
		OverheadPercent: math.Round(float64(totalOverhead)/float64(totalBytes)*1000) / 10,
	}
}

// Small payload: high relative overhead
// small := CalculateOverhead(64)   // overhead: ~55%

// Large payload: low relative overhead
// large := CalculateOverhead(1400) // overhead: ~5%

namespace Networking.Osi;

public readonly record struct LayerInfo(int HeaderSize, string Description);

public readonly record struct OverheadResult(
    int PayloadBytes,
    int OverheadBytes,
    int TotalBytes,
    double OverheadPercent);

/// <summary>
/// Demonstrating the encapsulation concept.
/// Each layer adds metadata (headers) to the payload.
/// </summary>
public static class PacketAnalyzer
{
    // Typical header sizes
    private const int EthernetHeader = 14 + 4;      // 14 header + 4 FCS
    private const int IpHeader = 20;                // without options
    private const int TcpHeader = 20;               // without options
    private const int TlsRecord = 5 + 16 + 16;      // record header + IV + auth tag

    /// <summary>
    /// Simulate the packet structure at each OSI layer.
    /// Useful for understanding what happens on an outgoing HTTPS request.
    /// </summary>
    public static IReadOnlyDictionary<string, LayerInfo> AnalyzeHttpPacket() =>
        new Dictionary<string, LayerInfo>
        {
            ["L7_Application"] = new(200, "HTTP request: GET /api/users HTTP/1.1"),
            ["L6_Presentation"] = new(40, "TLS 1.3 encryption wrapper"),
            ["L4_Transport"] = new(20, "TCP segment: src_port=49152, dst_port=443"),
            ["L3_Network"] = new(20, "IP packet: src=192.168.1.10, dst=93.184.216.34"),
            ["L2_DataLink"] = new(18, "Ethernet frame: src_mac=AA:BB:CC:DD:EE:FF"),
        };

    /// <summary>
    /// Calculate the overhead of network headers.
    /// Important for understanding MTU and fragmentation.
    /// </summary>
    public static OverheadResult CalculateOverhead(int payloadBytes)
    {
        var totalOverhead = EthernetHeader + IpHeader + TcpHeader + TlsRecord;
        var totalBytes = payloadBytes + totalOverhead;

        return new OverheadResult(
            PayloadBytes: payloadBytes,
            OverheadBytes: totalOverhead,
            TotalBytes: totalBytes,
            OverheadPercent: Math.Round((double)totalOverhead / totalBytes * 100, 1));
    }
}

// Small payload: high relative overhead
var small = PacketAnalyzer.CalculateOverhead(64);
// overhead: ~55% (for 64-byte payload, headers dominate)

// Large payload: low relative overhead
var large = PacketAnalyzer.CalculateOverhead(1400);
// overhead: ~5% (for 1400-byte payload near MTU)

from __future__ import annotations

from typing import NamedTuple

# Typical header sizes
ETHERNET_HEADER = 14 + 4  # 14 header + 4 FCS
IP_HEADER = 20  # without options
TCP_HEADER = 20  # without options
TLS_RECORD = 5 + 16 + 16  # record header + IV + auth tag

class LayerInfo(NamedTuple):
    header_size: int
    description: str

class OverheadResult(NamedTuple):
    payload_bytes: int
    overhead_bytes: int
    total_bytes: int
    overhead_percent: float

def analyze_http_packet() -> dict[str, LayerInfo]:
    """Simulate the packet structure at each OSI layer.

    Useful for understanding what happens on an outgoing HTTPS request.
    """
    return {
        "L7_Application": LayerInfo(200, "HTTP request: GET /api/users HTTP/1.1"),
        "L6_Presentation": LayerInfo(40, "TLS 1.3 encryption wrapper"),
        "L4_Transport": LayerInfo(20, "TCP segment: src_port=49152, dst_port=443"),
        "L3_Network": LayerInfo(20, "IP packet: src=192.168.1.10, dst=93.184.216.34"),
        "L2_DataLink": LayerInfo(18, "Ethernet frame: src_mac=AA:BB:CC:DD:EE:FF"),
    }

def calculate_overhead(payload_bytes: int) -> OverheadResult:
    """Calculate the overhead of network headers.

    Important for understanding MTU and fragmentation.
    """
    total_overhead = ETHERNET_HEADER + IP_HEADER + TCP_HEADER + TLS_RECORD
    total_bytes = payload_bytes + total_overhead

    return OverheadResult(
        payload_bytes=payload_bytes,
        overhead_bytes=total_overhead,
        total_bytes=total_bytes,
        overhead_percent=round(total_overhead / total_bytes * 100, 1),
    )

# Small payload: high relative overhead
small = calculate_overhead(64)
# overhead: ~55% (for 64-byte payload, headers dominate)

# Large payload: low relative overhead
large = calculate_overhead(1400)
# overhead: ~5% (for 1400-byte payload near MTU)

<?php

declare(strict_types=1);

/**
 * Understanding the difference between L4 and L7 load balancing.
 * This affects how you design your system architecture.
 */
final class LoadBalancerComparison
{
    /**
     * L4 Load Balancer characteristics.
     *
     * Works at TCP level - sees only IP addresses and ports.
     * Cannot make decisions based on HTTP content.
     *
     * @return array<string, mixed>
     */
    public static function l4Characteristics(): array
    {
        return [
            'protocol' => 'TCP/UDP',
            'routing_basis' => 'IP address + port number',
            'performance' => 'Very high (millions of connections/sec)',
            'ssl_termination' => 'No (pass-through)',
            'content_inspection' => 'No',
            'sticky_sessions' => 'By source IP only',
            'examples' => ['HAProxy (TCP mode)', 'AWS NLB', 'Linux IPVS'],
            'use_cases' => [
                'Database connection pooling',
                'Non-HTTP protocols (gRPC, MQTT)',
                'Ultra-high throughput requirements',
            ],
        ];
    }

    /**
     * L7 Load Balancer characteristics.
     *
     * Works at HTTP level - can inspect headers, paths, cookies.
     * Can make intelligent routing decisions.
     *
     * @return array<string, mixed>
     */
    public static function l7Characteristics(): array
    {
        return [
            'protocol' => 'HTTP/HTTPS',
            'routing_basis' => 'URL path, headers, cookies, body',
            'performance' => 'High (hundreds of thousands req/sec)',
            'ssl_termination' => 'Yes (terminates TLS)',
            'content_inspection' => 'Yes (HTTP headers, URL)',
            'sticky_sessions' => 'By cookie, header, or URL',
            'examples' => ['Nginx', 'HAProxy (HTTP mode)', 'AWS ALB', 'Envoy'],
            'use_cases' => [
                'Microservice routing (/api/users -> users-service)',
                'A/B testing (route % of traffic)',
                'Rate limiting per endpoint',
                'SSL termination',
            ],
        ];
    }
}

package lb

// LBCharacteristics describes load balancer properties.
type LBCharacteristics struct {
	Protocol          string
	RoutingBasis      string
	Performance       string
	SSLTermination    bool
	ContentInspection bool
	StickySessions    string
	Examples          []string
	UseCases          []string
}

// L4Characteristics returns L4 (transport layer) load balancer properties.
// Works at TCP level — sees only IP addresses and ports.
func L4Characteristics() LBCharacteristics {
	return LBCharacteristics{
		Protocol:          "TCP/UDP",
		RoutingBasis:      "IP address + port number",
		Performance:       "Very high (millions of connections/sec)",
		SSLTermination:    false, // pass-through
		ContentInspection: false,
		StickySessions:    "By source IP only",
		Examples:          []string{"HAProxy (TCP mode)", "AWS NLB", "Linux IPVS"},
		UseCases: []string{
			"Database connection pooling",
			"Non-HTTP protocols (gRPC, MQTT)",
			"Ultra-high throughput requirements",
		},
	}
}

// L7Characteristics returns L7 (application layer) load balancer properties.
// Works at HTTP level — can inspect headers, paths, cookies.
func L7Characteristics() LBCharacteristics {
	return LBCharacteristics{
		Protocol:          "HTTP/HTTPS",
		RoutingBasis:      "URL path, headers, cookies, body",
		Performance:       "High (hundreds of thousands req/sec)",
		SSLTermination:    true,
		ContentInspection: true,
		StickySessions:    "By cookie, header, or URL",
		Examples:          []string{"Nginx", "HAProxy (HTTP mode)", "AWS ALB", "Envoy"},
		UseCases: []string{
			"Microservice routing (/api/users -> users-service)",
			"A/B testing (route % of traffic)",
			"Rate limiting per endpoint",
			"SSL termination",
		},
	}
}

namespace Networking.LoadBalancing;

public sealed record LbCharacteristics
{
    public required string Protocol { get; init; }
    public required string RoutingBasis { get; init; }
    public required string Performance { get; init; }
    public required bool SslTermination { get; init; }
    public required bool ContentInspection { get; init; }
    public required string StickySessions { get; init; }
    public required IReadOnlyList<string> Examples { get; init; }
    public required IReadOnlyList<string> UseCases { get; init; }
}

/// <summary>
/// Understanding the difference between L4 and L7 load balancing.
/// This affects how you design your system architecture.
/// </summary>
public static class LoadBalancerComparison
{
    /// <summary>
    /// L4 load balancer: works at TCP level, sees only IP addresses and ports.
    /// Cannot make decisions based on HTTP content.
    /// </summary>
    public static LbCharacteristics L4Characteristics() => new()
    {
        Protocol = "TCP/UDP",
        RoutingBasis = "IP address + port number",
        Performance = "Very high (millions of connections/sec)",
        SslTermination = false, // pass-through
        ContentInspection = false,
        StickySessions = "By source IP only",
        Examples = ["HAProxy (TCP mode)", "AWS NLB", "Linux IPVS"],
        UseCases =
        [
            "Database connection pooling",
            "Non-HTTP protocols (gRPC, MQTT)",
            "Ultra-high throughput requirements",
        ],
    };

    /// <summary>
    /// L7 load balancer: works at HTTP level, can inspect headers, paths, cookies.
    /// Can make intelligent routing decisions.
    /// </summary>
    public static LbCharacteristics L7Characteristics() => new()
    {
        Protocol = "HTTP/HTTPS",
        RoutingBasis = "URL path, headers, cookies, body",
        Performance = "High (hundreds of thousands req/sec)",
        SslTermination = true,
        ContentInspection = true,
        StickySessions = "By cookie, header, or URL",
        Examples = ["Nginx", "HAProxy (HTTP mode)", "AWS ALB", "Envoy", "YARP"],
        UseCases =
        [
            "Microservice routing (/api/users -> users-service)",
            "A/B testing (route % of traffic)",
            "Rate limiting per endpoint",
            "SSL termination",
        ],
    };
}

from __future__ import annotations

from dataclasses import dataclass

@dataclass(slots=True, frozen=True)
class LbCharacteristics:
    protocol: str
    routing_basis: str
    performance: str
    ssl_termination: bool
    content_inspection: bool
    sticky_sessions: str
    examples: tuple[str, ...]
    use_cases: tuple[str, ...]

def l4_characteristics() -> LbCharacteristics:
    """L4 load balancer: works at TCP level, sees only IP addresses and ports.

    Cannot make decisions based on HTTP content.
    """
    return LbCharacteristics(
        protocol="TCP/UDP",
        routing_basis="IP address + port number",
        performance="Very high (millions of connections/sec)",
        ssl_termination=False,  # pass-through
        content_inspection=False,
        sticky_sessions="By source IP only",
        examples=("HAProxy (TCP mode)", "AWS NLB", "Linux IPVS"),
        use_cases=(
            "Database connection pooling",
            "Non-HTTP protocols (gRPC, MQTT)",
            "Ultra-high throughput requirements",
        ),
    )

def l7_characteristics() -> LbCharacteristics:
    """L7 load balancer: works at HTTP level, can inspect headers, paths, cookies.

    Can make intelligent routing decisions.
    """
    return LbCharacteristics(
        protocol="HTTP/HTTPS",
        routing_basis="URL path, headers, cookies, body",
        performance="High (hundreds of thousands req/sec)",
        ssl_termination=True,
        content_inspection=True,
        sticky_sessions="By cookie, header, or URL",
        examples=("Nginx", "HAProxy (HTTP mode)", "AWS ALB", "Envoy", "Traefik"),
        use_cases=(
            "Microservice routing (/api/users -> users-service)",
            "A/B testing (route % of traffic)",
            "Rate limiting per endpoint",
            "SSL termination",
        ),
    )