get_network_load_balancer

Retrieve detailed configuration and status information for a specific Oracle Cloud Infrastructure network load balancer, including backend sets and listeners, to monitor and manage traffic distribution.

Instructions

Get detailed information about a specific network load balancer.

Args:
    network_load_balancer_id: OCID of the network load balancer to retrieve

Returns:
    Detailed network load balancer information including backend sets and listeners

Input Schema

TableJSON Schema

Name	Required	Description	Default
`network_load_balancer_id`	Yes

Implementation Reference

mcp_server_oci/tools/load_balancer.py:207-294 (handler)

Core handler function that retrieves and formats network load balancer details from OCI API, including backend sets, listeners, IP addresses, and other configurations.

def get_network_load_balancer(network_load_balancer_client: oci.network_load_balancer.NetworkLoadBalancerClient, 
                               network_load_balancer_id: str) -> Dict[str, Any]:
    """
    Get details of a specific network load balancer.
    
    Args:
        network_load_balancer_client: OCI NetworkLoadBalancer client
        network_load_balancer_id: OCID of the network load balancer
        
    Returns:
        Details of the network load balancer
    """
    try:
        nlb = network_load_balancer_client.get_network_load_balancer(network_load_balancer_id).data
        
        # Format backend sets
        backend_sets = {}
        if nlb.backend_sets:
            for name, backend_set in nlb.backend_sets.items():
                backend_sets[name] = {
                    "name": name,
                    "policy": backend_set.policy,
                    "is_preserve_source": backend_set.is_preserve_source,
                    "backends": [
                        {
                            "ip_address": backend.ip_address,
                            "port": backend.port,
                            "weight": backend.weight,
                            "target_id": backend.target_id,
                            "is_drain": backend.is_drain,
                            "is_backup": backend.is_backup,
                            "is_offline": backend.is_offline,
                        }
                        for backend in backend_set.backends
                    ] if backend_set.backends else [],
                    "health_checker": {
                        "protocol": backend_set.health_checker.protocol,
                        "port": backend_set.health_checker.port,
                        "url_path": backend_set.health_checker.url_path,
                        "return_code": backend_set.health_checker.return_code,
                        "retries": backend_set.health_checker.retries,
                        "timeout_in_millis": backend_set.health_checker.timeout_in_millis,
                        "interval_in_millis": backend_set.health_checker.interval_in_millis,
                        "request_data": backend_set.health_checker.request_data,
                        "response_data": backend_set.health_checker.response_data,
                    } if backend_set.health_checker else None,
                }
        
        # Format listeners
        listeners = {}
        if nlb.listeners:
            for name, listener in nlb.listeners.items():
                listeners[name] = {
                    "name": name,
                    "default_backend_set_name": listener.default_backend_set_name,
                    "port": listener.port,
                    "protocol": listener.protocol,
                    "ip_version": listener.ip_version,
                }
        
        nlb_details = {
            "id": nlb.id,
            "display_name": nlb.display_name,
            "compartment_id": nlb.compartment_id,
            "lifecycle_state": nlb.lifecycle_state,
            "time_created": str(nlb.time_created),
            "is_private": nlb.is_private,
            "ip_addresses": [
                {
                    "ip_address": ip.ip_address,
                    "is_public": ip.is_public,
                    "ip_version": ip.ip_version,
                }
                for ip in nlb.ip_addresses
            ] if nlb.ip_addresses else [],
            "subnet_id": nlb.subnet_id,
            "network_security_group_ids": nlb.network_security_group_ids,
            "is_preserve_source_destination": nlb.is_preserve_source_destination,
            "backend_sets": backend_sets,
            "listeners": listeners,
        }
        
        logger.info(f"Retrieved details for network load balancer {network_load_balancer_id}")
        return nlb_details
        
    except Exception as e:
        logger.exception(f"Error getting network load balancer details: {e}")
        raise

mcp_server_oci/mcp_server.py:1264-1280 (registration)

MCP tool registration decorator @mcp.tool(name='get_network_load_balancer') with wrapper for error handling and logging, delegating to the imported handler function.

@mcp.tool(name="get_network_load_balancer")
@mcp_tool_wrapper(
    start_msg="Getting network load balancer details for {network_load_balancer_id}...",
    success_msg="Retrieved network load balancer details successfully",
    error_prefix="Error getting network load balancer details"
)
async def mcp_get_network_load_balancer(ctx: Context, network_load_balancer_id: str) -> Dict[str, Any]:
    """
    Get detailed information about a specific network load balancer.

    Args:
        network_load_balancer_id: OCID of the network load balancer to retrieve

    Returns:
        Detailed network load balancer information including backend sets and listeners
    """
    return get_network_load_balancer(oci_clients["network_load_balancer"], network_load_balancer_id)

mcp_server_oci/mcp_server.py:81-86 (registration)

Import statement bringing the get_network_load_balancer handler into the MCP server module for registration.

from mcp_server_oci.tools.load_balancer import (
    list_load_balancers,
    get_load_balancer,
    list_network_load_balancers,
    get_network_load_balancer,
)

OCI MCP Server