DMTF Redfish API for Out-of-Band Server Management

Updated on
9 min read

When a server operating system is unresponsive, administrators still need a way to check hardware health, reach a remote console, or recover the machine. The DMTF Redfish API provides a common web-based interface for managing servers and other data-center equipment, often through a baseboard management controller (BMC). This explainer describes its resource model, how it differs from older management methods, and how to inspect an authorized Redfish service with read-only requests.

What Is the Redfish API?

Redfish is a DMTF standard for managing systems through a RESTful interface and a schema-based data model. It uses familiar web technologies: clients make HTTP requests, services return JSON resources, and resource links connect related parts of the inventory. DMTF describes Redfish as a human-readable and machine-oriented standard for modern systems management in its Redfish overview.

A Redfish service may run on a BMC and be reachable over a dedicated management network even when the host operating system is unavailable. Some platforms also expose Redfish through a host interface, so the protocol itself does not guarantee that a request travels out of band. The management path depends on the system’s implementation and network configuration.

Redfish standardizes the interface and many resource definitions; it does not prescribe a particular BMC, server design, or vendor’s internal implementation. Hardware vendors can add extensions and may support different optional features. Clients should therefore discover the service’s resources and capabilities instead of assuming every server behaves identically.

The Problem Redfish Solves

Data centers contain servers from different manufacturers and generations. Before a common model, administrators often had to learn a vendor-specific command-line tool, proprietary API, or older protocol for each platform. That made fleet inventory, health monitoring, firmware workflows, and automation harder to keep consistent.

The challenge is especially visible during a host failure. In-band tools depend on the operating system and its network stack. If the OS hangs, an in-band agent stops responding, or the host’s network is misconfigured, those tools may no longer be reachable. A separate BMC can preserve a management path for hardware status, power state, and remote console access.

Redfish gives management software a structured way to discover and work with supported resources across implementations. It reduces the need to translate every operation into a separate vendor protocol, but it does not eliminate differences in firmware quality, optional capabilities, permissions, or vendor extensions.

How Redfish Works

A client connects to a Redfish service over HTTPS, commonly starting at the service root, /redfish/v1/. That root advertises links to resource collections and services. A client follows the returned @odata.id links to reach resources instead of constructing every URI from assumptions.

Resources represent objects such as a system, chassis, processor, memory device, network adapter, manager, or storage controller. JSON properties describe the resource; OData annotations provide metadata and links. Collections contain member links, while schema definitions describe the meaning and types of standard properties. DMTF publishes these definitions separately in the Redfish Data Model Specification.

HTTP methods express the operation. GET reads a resource; methods such as PATCH or POST may change configuration or request an action when the service supports it and the account has the required privileges. Some operations take time and return a task monitor rather than completing immediately. A client must interpret the response and follow the service’s task information instead of treating every accepted request as completed.

Aspect Redfish IPMI-style management Vendor-specific management API
Interface model RESTful resources and links Command and message-oriented protocol Varies by vendor and product
Typical data representation JSON with schema and OData metadata Structured command responses Commonly JSON or proprietary formats
Discovery Service root and resource links Command-specific capabilities Depends on the API
Interoperability Standardized core with optional extensions Established protocol with a different model Often limited to a vendor’s ecosystem
Transport and security Commonly HTTPS with service authentication and privileges Varies by version and implementation Varies by API and deployment
Automation approach Follow resource links and supported actions Use an IPMI client and command set Use the vendor’s SDK, API, or CLI

These are broad distinctions, not a feature guarantee. A particular platform may expose only part of Redfish, and administrators may still need a vendor tool for unsupported features. The Redfish specification defines protocol behavior and implementation requirements; the service’s own responses and documentation remain the source of truth for its available resources.

Components and Key Concepts

Redfish service: The API endpoint and resource model provided by a system. Its service root is the discovery entry point. A service can expose systems, chassis, managers, update, task, and event resources, subject to implementation support.

BMC or management controller: The controller that provides access to hardware management functions. It may have its own processor, firmware, network interface, and power source. Redfish is one interface it can expose; Redfish and BMC are not synonyms.

Resource and collection: A resource describes one object and has an identifier. A collection groups links to multiple resources. The representation can include standard properties, optional fields, and vendor extensions.

Schema: A machine-readable description of resource properties, types, and relationships. Schema support helps clients understand responses, but it does not mean every service implements every schema or property.

Privilege and role: A user’s permissions determine which resources and operations are allowed. Reading inventory, changing configuration, updating firmware, and controlling power should not be treated as equivalent access. Grant only the privileges required for the management task.

Task and event service: Long-running work may be represented by a task whose status can be polled. Event services can deliver alerts when supported and configured. These mechanisms complement, rather than replace, health polling and log retention.

The DMTF Redfish Developer Hub provides official schema files, mockups, educational resources, and implementation material for developers building clients or services.

Real-World Use Cases

  • Fleet inventory: Collect model, serial, firmware, processor, memory, and network information through a consistent API, then reconcile it with a hardware asset database.
  • Hardware health monitoring: Read sensor and status resources to detect conditions such as temperature warnings, failed drives, or power-supply faults. Thresholds and exposed sensor details vary by platform.
  • Remote recovery: Check host power and use a supported remote console when the operating system or normal network path is unavailable. This is a recovery path, not a substitute for backups or tested runbooks.
  • Provisioning and maintenance: Integrate supported configuration or firmware operations into controlled change processes. Validate each vendor’s supported features and test on a non-production system before applying changes broadly.
  • Data-center orchestration: Combine server management with virtualization, inventory, and monitoring systems. Keep API identity and access policy separate from workload credentials.

Getting Started: Inspect a Redfish Service

Use an account and management endpoint you are authorized to administer. Redfish access should be confined to a trusted management network or approved administrative path, protected with valid TLS certificates, and governed by least-privilege accounts. Do not expose a BMC directly to the public internet.

The example below needs curl and jq on a Bash-compatible system, the controller’s DNS name, and the trusted certificate authority file for its HTTPS certificate. It performs only GET requests. With a username but no password supplied, curl prompts interactively for the password; do not put credentials in the URL or commit them to scripts.

REDFISH_HOST='bmc.example.net'
read -r -p 'Redfish username: ' REDFISH_USER
export REDFISH_USER

curl --fail --silent --show-error \
  --user "$REDFISH_USER" \
  --cacert ./management-ca.pem \
  "https://${REDFISH_HOST}/redfish/v1/" |
  jq '{
    RedfishVersion: .RedfishVersion,
    Systems: .Systems["@odata.id"],
    Chassis: .Chassis["@odata.id"]
  }'

Replace the example host and certificate path with values from the administrator’s environment. Keep certificate verification enabled. If the request succeeds, inspect the returned collection links and follow the @odata.id supplied by the service. For example, if the service root advertises a systems collection, request the returned collection URI:

curl --fail --silent --show-error \
  --user "$REDFISH_USER" \
  --cacert ./management-ca.pem \
  "https://${REDFISH_HOST}/redfish/v1/Systems" |
  jq -r '.Members[]? | .["@odata.id"]'

Use the collection’s member links to inspect individual systems. Confirm that the response content type is JSON, that certificate validation succeeds, and that the account can read the expected properties. Missing fields or collections may indicate implementation differences or privileges, not necessarily a broken service.

For troubleshooting, first verify DNS, the management route, controller availability, and the certificate chain using the approved administrative environment. An HTTP 401 generally points to authentication, while 403 indicates the identity was recognized but lacks permission. A 404 can mean the requested resource is not implemented or the client used a URI the service did not advertise. Inspect the JSON error body for extended messages, but remove sensitive details before sharing logs.

Treat write operations, firmware updates, and power actions as controlled changes. They can interrupt workloads or make a host unavailable. Before implementing them, consult the platform’s Redfish documentation, confirm the account privilege and action parameters, test a recovery plan, and use an explicit approval and change window. This explainer intentionally demonstrates inspection only.

Common Misconceptions

  • “Redfish is a BMC.” Redfish is a standard interface. A BMC is a management controller that may implement it.
  • “Every Redfish service supports every feature.” The standard defines common behavior and schemas, but implementations vary. Discover resources and check vendor support.
  • “Redfish always means out-of-band access.” A Redfish client may connect through an out-of-band BMC network or an in-band host interface. The path is determined by the deployment.
  • “A successful request means an operation is finished.” Some operations are asynchronous and return a task to monitor. Acknowledgment is not completion.
  • “Standardized APIs remove the need for security controls.” A common interface can make automation easier, but privileged management access remains a high-impact control plane. Restrict connectivity, use individual accounts, validate TLS, and audit changes.

Changelog

  • Initial publication with a protocol overview and read-only inspection example.

Last updated on publication.

TBO Editorial

About the Author

TBO Editorial writes about the latest updates about products and services related to Technology, Business, Finance & Lifestyle. Do get in touch if you want to share any useful article with our community.