tessl/pypi-kubernetes

Python client library for interacting with Kubernetes clusters through the Kubernetes API

—

Pending

Overview

Eval results

Files

Networking

Name: tessl/pypi-kubernetes
Author: tessl

Network management capabilities including ingress controllers, network policies, and service networking. Provides control over network traffic flow, ingress routing, and network security policies within Kubernetes clusters.

Capabilities

Ingress Management

Manage HTTP/HTTPS ingress routing and load balancing for services, including ingress controllers and routing rules.

class NetworkingV1Api:
    def create_namespaced_ingress(
        self,
        namespace: str,
        body: V1Ingress,
        dry_run: str = None,
        field_manager: str = None,
        pretty: str = None
    ) -> V1Ingress:
        """Create an ingress resource for HTTP/HTTPS routing."""
    
    def list_namespaced_ingress(
        self,
        namespace: str,
        pretty: str = None,
        field_selector: str = None,
        label_selector: str = None,
        limit: int = None,
        timeout_seconds: int = None,
        watch: bool = None
    ) -> V1IngressList:
        """List ingress resources in specified namespace."""
    
    def read_namespaced_ingress(
        self,
        name: str,
        namespace: str,
        pretty: str = None
    ) -> V1Ingress:
        """Read specified ingress resource."""
    
    def patch_namespaced_ingress(
        self,
        name: str,
        namespace: str,
        body: object,
        dry_run: str = None,
        field_manager: str = None,
        pretty: str = None
    ) -> V1Ingress:
        """Update specified ingress resource."""
    
    def delete_namespaced_ingress(
        self,
        name: str,
        namespace: str,
        dry_run: str = None,
        grace_period_seconds: int = None,
        orphan_dependents: bool = None,
        propagation_policy: str = None,
        pretty: str = None
    ) -> V1Status:
        """Delete specified ingress resource."""

Ingress Classes

Manage ingress controller configurations and ingress class definitions.

class NetworkingV1Api:
    def create_ingress_class(
        self,
        body: V1IngressClass,
        dry_run: str = None,
        field_manager: str = None,
        pretty: str = None
    ) -> V1IngressClass:
        """Create an ingress class."""
    
    def list_ingress_class(
        self,
        pretty: str = None,
        field_selector: str = None,
        label_selector: str = None,
        limit: int = None,
        timeout_seconds: int = None,
        watch: bool = None
    ) -> V1IngressClassList:
        """List ingress classes."""
    
    def read_ingress_class(
        self,
        name: str,
        pretty: str = None
    ) -> V1IngressClass:
        """Read specified ingress class."""
    
    def delete_ingress_class(
        self,
        name: str,
        dry_run: str = None,
        grace_period_seconds: int = None,
        pretty: str = None
    ) -> V1Status:
        """Delete specified ingress class."""

Network Policies

Define network security policies controlling traffic flow between pods and external networks.

class NetworkingV1Api:
    def create_namespaced_network_policy(
        self,
        namespace: str,
        body: V1NetworkPolicy,
        dry_run: str = None,
        field_manager: str = None,
        pretty: str = None
    ) -> V1NetworkPolicy:
        """Create a network policy for traffic control."""
    
    def list_namespaced_network_policy(
        self,
        namespace: str,
        pretty: str = None,
        field_selector: str = None,
        label_selector: str = None,
        limit: int = None,
        timeout_seconds: int = None,
        watch: bool = None
    ) -> V1NetworkPolicyList:
        """List network policies in specified namespace."""
    
    def read_namespaced_network_policy(
        self,
        name: str,
        namespace: str,
        pretty: str = None
    ) -> V1NetworkPolicy:
        """Read specified network policy."""
    
    def patch_namespaced_network_policy(
        self,
        name: str,
        namespace: str,
        body: object,
        dry_run: str = None,
        field_manager: str = None,
        pretty: str = None
    ) -> V1NetworkPolicy:
        """Update specified network policy."""
    
    def delete_namespaced_network_policy(
        self,
        name: str,
        namespace: str,
        dry_run: str = None,
        grace_period_seconds: int = None,
        pretty: str = None
    ) -> V1Status:
        """Delete specified network policy."""

Service CIDR Management

Manage IP address ranges for cluster services and networking configuration.

class NetworkingV1Api:
    def create_service_cidr(
        self,
        body: V1ServiceCIDR,
        dry_run: str = None,
        field_manager: str = None,
        pretty: str = None
    ) -> V1ServiceCIDR:
        """Create a service CIDR range."""
    
    def list_service_cidr(
        self,
        pretty: str = None,
        field_selector: str = None,
        label_selector: str = None,
        limit: int = None,
        timeout_seconds: int = None,
        watch: bool = None
    ) -> V1ServiceCIDRList:
        """List service CIDR ranges."""
    
    def create_ip_address(
        self,
        body: V1IPAddress,
        dry_run: str = None,
        field_manager: str = None,
        pretty: str = None
    ) -> V1IPAddress:
        """Create an IP address resource."""
    
    def list_ip_address(
        self,
        pretty: str = None,
        field_selector: str = None,
        label_selector: str = None,
        limit: int = None,
        timeout_seconds: int = None,
        watch: bool = None
    ) -> V1IPAddressList:
        """List IP address resources."""

Resource Types

V1Ingress

class V1Ingress:
    api_version: str
    kind: str
    metadata: V1ObjectMeta
    spec: V1IngressSpec
    status: V1IngressStatus

class V1IngressSpec:
    default_backend: V1IngressBackend
    ingress_class_name: str
    rules: list[V1IngressRule]
    tls: list[V1IngressTLS]

V1NetworkPolicy

class V1NetworkPolicy:
    api_version: str
    kind: str
    metadata: V1ObjectMeta
    spec: V1NetworkPolicySpec

class V1NetworkPolicySpec:
    egress: list[V1NetworkPolicyEgressRule]
    ingress: list[V1NetworkPolicyIngressRule]
    pod_selector: V1LabelSelector
    policy_types: list[str]

V1IngressClass

class V1IngressClass:
    api_version: str
    kind: str
    metadata: V1ObjectMeta
    spec: V1IngressClassSpec

class V1IngressClassSpec:
    controller: str
    parameters: V1IngressClassParametersReference

Usage Examples

Creating an Ingress Resource

from kubernetes import client, config

# Load configuration
config.load_kube_config()

# Create networking API client
networking_v1 = client.NetworkingV1Api()

# Define ingress specification
ingress_spec = client.V1IngressSpec(
    rules=[
        client.V1IngressRule(
            host="example.com",
            http=client.V1HTTPIngressRuleValue(
                paths=[
                    client.V1HTTPIngressPath(
                        path="/",
                        path_type="Prefix",
                        backend=client.V1IngressBackend(
                            service=client.V1IngressServiceBackend(
                                name="web-service",
                                port=client.V1ServiceBackendPort(number=80)
                            )
                        )
                    )
                ]
            )
        )
    ]
)

# Create ingress resource
ingress = client.V1Ingress(
    api_version="networking.k8s.io/v1",
    kind="Ingress",
    metadata=client.V1ObjectMeta(name="web-ingress"),
    spec=ingress_spec
)

# Apply to cluster
result = networking_v1.create_namespaced_ingress(
    namespace="default",
    body=ingress
)
print(f"Ingress created: {result.metadata.name}")

Creating a Network Policy

# Define network policy to allow traffic only from specific pods
network_policy_spec = client.V1NetworkPolicySpec(
    pod_selector=client.V1LabelSelector(
        match_labels={"app": "web"}
    ),
    policy_types=["Ingress"],
    ingress=[
        client.V1NetworkPolicyIngressRule(
            _from=[
                client.V1NetworkPolicyPeer(
                    pod_selector=client.V1LabelSelector(
                        match_labels={"app": "frontend"}
                    )
                )
            ],
            ports=[
                client.V1NetworkPolicyPort(
                    port=80,
                    protocol="TCP"
                )
            ]
        )
    ]
)

# Create network policy
network_policy = client.V1NetworkPolicy(
    api_version="networking.k8s.io/v1",
    kind="NetworkPolicy",
    metadata=client.V1ObjectMeta(name="web-netpol"),
    spec=network_policy_spec
)

# Apply to cluster
result = networking_v1.create_namespaced_network_policy(
    namespace="default",
    body=network_policy
)
print(f"Network policy created: {result.metadata.name}")

Managing Ingress Classes

# Create an ingress class for nginx controller
ingress_class_spec = client.V1IngressClassSpec(
    controller="k8s.io/ingress-nginx"
)

ingress_class = client.V1IngressClass(
    api_version="networking.k8s.io/v1",
    kind="IngressClass",
    metadata=client.V1ObjectMeta(
        name="nginx",
        annotations={
            "ingressclass.kubernetes.io/is-default-class": "true"
        }
    ),
    spec=ingress_class_spec
)

# Create ingress class
result = networking_v1.create_ingress_class(body=ingress_class)
print(f"Ingress class created: {result.metadata.name}")

# List all ingress classes
ingress_classes = networking_v1.list_ingress_class()
for ic in ingress_classes.items:
    print(f"Ingress class: {ic.metadata.name}, controller: {ic.spec.controller}")

Import Statements

from kubernetes import client
from kubernetes.client import NetworkingV1Api
from kubernetes.client import V1Ingress, V1IngressSpec, V1IngressRule
from kubernetes.client import V1NetworkPolicy, V1NetworkPolicySpec
from kubernetes.client import V1IngressClass, V1IngressClassSpec

Install with Tessl CLI