System Configuration Service v1

Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

Commercial off-the-shelf BMCs and HPE-built controllers will need to have various parameters configured on them such as NTP server, syslog server, SSH keys, access credentials. These parameters are automatically configured when the targets like BMC and controllers are discovered. The System Configuration Service makes it possible for administrators to configure these parameters at anytime on multiple targets in a single operation. The System Configuration Service runs on the non-compute worker node.

The REST API provides the following functions:

  • Set or retrieve network protocol (NWP) parameters (NTP, syslog servers, SSH keys) for specified targets (xnames or groups). Only Redfish access credentials can be configured for Commercial off-the-shelf BMCs or BMC’s in air cooled hardware. The other parameters are not applicable.
  • Set Redfish access credentials for specified targets
  • Check service health

Resources

/bmc/dumpcfg

Retrieve network protocol parameters like NTP, syslog server, and SSH keys for a set of controllers.

/bmc/loadcfg

Configure NTP, syslog server, and SSH keys for a set of controllers.

/bmc/cfg/{xname}

Retrieve or set NTP, syslog server, and SSH keys for a single controller.

/bmc/discreetcreds

Configure discrete access credentials for target BMCs or controllers.

/bmc/creds/{xname}

Configure or fetch (with authorization) access credentials for a single BMC or controller.

/bmc/globalcreds

Configure the same access credentials for multiple BMCs or controllers.

/bmc/createcerts

Create BMC TLS cert/key pairs and store securely for later use.

/bmc/deletecerts

Delet BMC TLS cert/key pairs and store securely for later use.

/bmc/fetchcerts

Fetch previously created BMC TLS certs for viewing.

/bmc/setcerts

Apply previously created BMC TLS cert/key pairs to target Redfish BMCs.

/bmc/setcert/{xname}

Apply previously created BMC TLS cert/key pairs to a single target Redfish BMCs.

/health

Retrieve the current health state of the service.

Workflows

Retrieve syslog, NTP server and/or SSH key information on a single or multiple targets

POST /bmc/dumpcfg

Send a JSON payload with targets to retrieve. Targets can be xnames of BMCs or controllers, or group IDs. Returns a JSON payload containing NTP server information on specified targets.

GET /bmc/cfg/{xname}?params=NTPServer+SyslogServer

Returns a JSON payload containing only NTP and syslog server from a single target.

Set syslog and NTP server and/or SSH key information on a single or multiple targets

POST /bmc/loadcfg

Send a JSON payload with parameters to set and a list of targets. Targets can be xnames of BMCs or controllers, or group IDs. Returns a JSON payload with the results of the operation.

POST /bmc/cfg/{xname}?params=NTPServer+SSHKey

Returns a JSON payload containing NTP and SSH key information from a single target.

Set login credentials on controllers

POST /bmc/discreetcreds

Sets login credentials on a set of controllers. Targets can be xnames of controllers or group IDs.

Create or delete BMC TLS cert/key pairs

POST /bmc/createcerts

Send a JSON payload with BMC domain and targets. Creates a TLS cert/key pair for each BMC domain (e.g. cabinet) and stores it in secure storage for later use.

POST /bmc/deletecerts

Send a JSON payload with BMC domain and targets. Deletes all applicable TLS cert/key pairs from secure storage.

Fetch and view TLS certs

POST /bmc/fetchcerts

Send a JSON payload with BMC targets. Fetches applicable TLS certs and returns them in a JSON payload. Note that cert data is fetched, but not the private key data.

Apply TLS Certs to BMCs

POST /bmc/setcerts

Send a JSON payload with BMC targets. Fetch applicable TLS certs/keys from secure storage. Apply cert/key pairs to target BMCs.

POST /bmc/setcert/{xname}?Force=true&Domain=cabinet

No JSON payload needed. Fetch TLS cert/key pair from secure storage for target BMC specified by {xname}. Apply cert/key pair to target BMC. Force defaults to false, Domain defaults to cabinet.

Bios

GET /bmc/bios/{xname}/{bios_field}

Get TPM State in the BIOS settings.

PATCH /bmc/bios/{xname}/{bios_field}

Set TPM State in the BIOS settings.

Base URLs:

License: Cray Proprietary

Authentication

  • HTTP Authentication, scheme: bearer

nwp

Endpoints that set or get Redfish Network Protocol information

post__bmc_dumpcfg

Code samples

POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/dumpcfg HTTP/1.1
Host: api-gw-service-nmn.local
Content-Type: application/json
Accept: application/json

# You can also use wget
curl -X POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/dumpcfg \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api-gw-service-nmn.local/apis/scsd/v1/bmc/dumpcfg', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-gw-service-nmn.local/apis/scsd/v1/bmc/dumpcfg", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /bmc/dumpcfg

Retrieve the Redfish network protocol data for a set of targets

Get the Redfish Network Protocol data (NTP server, syslog server, SSH key) for a set of targets. The POST payload contains the parameters to retrieve along with a list of targets.

Body parameter

{
  "Targets": [
    "x0c0s0b0"
  ],
  "Params": [
    "NTPServerInfo"
  ]
}

Parameters

Name In Type Required Description
body body bmc_dumpcfg_request false none

Example responses

200 Response

{
  "Targets": [
    {
      "StatusCode": 0,
      "StatusMsg": "string",
      "Xname": "x0c0s0b0",
      "Params": {
        "NTPServerInfo": {
          "NTPServers": "sms-ncn-w001",
          "Port": 0,
          "ProtocolEnabled": true
        },
        "SyslogServerInfo": {
          "SyslogServers": "sms-ncn-w001",
          "Port": 0,
          "ProtocolEnabled": true
        },
        "SSHKey": "xyzabc123...",
        "SSHConsoleKey": "xyzabc123..."
      }
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK. The data was succesfully retrieved bmc_dumpcfg_response
404 Not Found Endpoint not found None
405 Method Not Allowed Invalid method, only POST is allowed None
To perform this operation, you must be authenticated by means of one of the following methods: bearerAuth

post__bmc_loadcfg

Code samples

POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/loadcfg HTTP/1.1
Host: api-gw-service-nmn.local
Content-Type: application/json
Accept: application/json

# You can also use wget
curl -X POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/loadcfg \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api-gw-service-nmn.local/apis/scsd/v1/bmc/loadcfg', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-gw-service-nmn.local/apis/scsd/v1/bmc/loadcfg", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /bmc/loadcfg

Set the Redfish network protocol data for a set of targets

Set the Redfish network protocol data (NTP server, syslog server, SSH key) for a set of targets. The POST payload contains the parameters to set along with a list of targets.

The Force field is optional. If present, and set to ’true’, the Redfish operations will be attempted without contacting HSM and without verifying if the targets are present or are in a good state. If the “Force” field is not present or is present but set to ‘false’, HSM will be used.

Body parameter

{
  "Force": true,
  "Targets": [
    "x0c0s0b0"
  ],
  "Params": {
    "NTPServer": {
      "NTPServers": "sms-ncn-w001",
      "Port": 0,
      "ProtocolEnabled": true
    },
    "SyslogServer": {
      "SyslogServers": "sms-ncn-w001",
      "Port": 0,
      "ProtocolEnabled": true
    },
    "SSHKey": "xyzabc123...",
    "SSHConsoleKey": "xyzabc123..."
  }
}

Parameters

Name In Type Required Description
body body bmc_loadcfg_request false none

Example responses

200 Response

{
  "Targets": [
    {
      "Xname": "x0c0s0b0",
      "StatusCode": 200,
      "StatusMsg": "OK"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK. The data was succesfully retrieved multi_post_response
404 Not Found Endpoint not found None
405 Method Not Allowed Invalid method, only POST is allowed None
To perform this operation, you must be authenticated by means of one of the following methods: bearerAuth

get__bmc_cfg_{xname}

Code samples

GET https://api-gw-service-nmn.local/apis/scsd/v1/bmc/cfg/{xname} HTTP/1.1
Host: api-gw-service-nmn.local
Accept: application/json

# You can also use wget
curl -X GET https://api-gw-service-nmn.local/apis/scsd/v1/bmc/cfg/{xname} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api-gw-service-nmn.local/apis/scsd/v1/bmc/cfg/{xname}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-gw-service-nmn.local/apis/scsd/v1/bmc/cfg/{xname}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /bmc/cfg/{xname}

Retrieve Redfish network protocol data for a single target

Retrieve selected Redfish network protocol data for a single target. You can select NTP server, Syslog server, or SSH key. If nothing is specified, all Redfish network protocol parameters are returned.

Parameters

Name In Type Required Description
xname path xname true none
param query string false none

Example responses

200 Response

{
  "Force": true,
  "Params": {
    "NTPServerInfo": {
      "NTPServers": "sms-ncn-w001",
      "Port": 0,
      "ProtocolEnabled": true
    },
    "SyslogServerInfo": {
      "SyslogServers": "sms-ncn-w001",
      "Port": 0,
      "ProtocolEnabled": true
    },
    "SSHKey": "xyzabc123...",
    "SSHConsoleKey": "xyzabc123..."
  }
}

Responses

Status Meaning Description Schema
200 OK OK. The data was succesfully retrieved cfg_get_single
404 Not Found Endpoint not found None
405 Method Not Allowed Invalid method, only GET,POST is allowed None
To perform this operation, you must be authenticated by means of one of the following methods: bearerAuth

post__bmc_cfg_{xname}

Code samples

POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/cfg/{xname} HTTP/1.1
Host: api-gw-service-nmn.local
Content-Type: application/json
Accept: application/json

# You can also use wget
curl -X POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/cfg/{xname} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api-gw-service-nmn.local/apis/scsd/v1/bmc/cfg/{xname}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-gw-service-nmn.local/apis/scsd/v1/bmc/cfg/{xname}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /bmc/cfg/{xname}

Set Redfish network protocol data for a single target

Set selected Redfish network protocol data for a single target. Payload body specifies NTP server, syslog server, or SSH key.

The Force field is optional. If present, and set to ’true’, the Redfish operations will be attempted without contacting HSM and without verifying if the targets are present or are in a good state. If the “Force” field is not present or is present but set to ‘false’, HSM will be used.

Body parameter

{
  "Force": true,
  "Params": {
    "NTPServerInfo": {
      "NTPServers": "sms-ncn-w001",
      "Port": 0,
      "ProtocolEnabled": true
    },
    "SyslogServerInfo": {
      "SyslogServers": "sms-ncn-w001",
      "Port": 0,
      "ProtocolEnabled": true
    },
    "SSHKey": "xyzabc123...",
    "SSHConsoleKey": "xyzabc123..."
  }
}

Parameters

Name In Type Required Description
body body cfg_post_single false none
xname path xname true none
param query string false none

Example responses

200 Response

{
  "StatusMsg": "OK"
}

Responses

Status Meaning Description Schema
200 OK OK. The data was succesfully set cfg_rsp_status
404 Not Found Endpoint not found None
405 Method Not Allowed Invalid method, only GET,POST is allowed None
To perform this operation, you must be authenticated by means of one of the following methods: bearerAuth

creds

Endpoints that set Redfish access credentials

post__bmc_discreetcreds

Code samples

POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/discreetcreds HTTP/1.1
Host: api-gw-service-nmn.local
Content-Type: application/json
Accept: application/json

# You can also use wget
curl -X POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/discreetcreds \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api-gw-service-nmn.local/apis/scsd/v1/bmc/discreetcreds', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-gw-service-nmn.local/apis/scsd/v1/bmc/discreetcreds", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /bmc/discreetcreds

Set the controller login credentials for a set of targets

Set discrete controller login credentials for a set of targets. The POST payload contains the parameters to set along with a list of targets.

The Force field is optional. If present, and set to ’true’, the Redfish operations will be attempted without contacting HSM and without verifying if the targets are present or are in a good state. If the “Force” field is not present or is present but set to ‘false’, HSM will be used.

Body parameter

{
  "Force": true,
  "Targets": [
    {
      "Xname": "x0c0s0b0",
      "Creds": {
        "Username": "admin-user",
        "Password": "admin-pw"
      }
    }
  ]
}

Parameters

Name In Type Required Description
body body creds_components false none

Example responses

200 Response

{
  "Targets": [
    {
      "Xname": "x0c0s0b0",
      "StatusCode": 200,
      "StatusMsg": "OK"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK. The data was succesfully set multi_post_response
404 Not Found Endpoint not found None
405 Method Not Allowed Invalid method, only POST is allowed None
To perform this operation, you must be authenticated by means of one of the following methods: bearerAuth

post__bmc_creds_{xname}

Code samples

POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/creds/{xname} HTTP/1.1
Host: api-gw-service-nmn.local
Content-Type: application/json
Accept: application/json

# You can also use wget
curl -X POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/creds/{xname} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api-gw-service-nmn.local/apis/scsd/v1/bmc/creds/{xname}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-gw-service-nmn.local/apis/scsd/v1/bmc/creds/{xname}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /bmc/creds/{xname}

Set controller login credentials for a single target

Set controller login credentials for a single target. The POST payload contains the parameters to set along with a list of targets.

The Force field is optional. If present, and set to ’true’, the Redfish operations will be attempted without contacting HSM and without verifying if the targets are present or are in a good state. If the “Force” field is not present or is present but set to ‘false’, HSM will be used.

Body parameter

{
  "Force": true,
  "Creds": {
    "Username": "admin-user",
    "Password": "admin-pw"
  }
}

Parameters

Name In Type Required Description
body body creds_single false none
xname path xname true none

Example responses

200 Response

{
  "StatusMsg": "OK"
}

Responses

Status Meaning Description Schema
200 OK OK. The data was succesfully set cfg_rsp_status
404 Not Found Endpoint not found None
405 Method Not Allowed Invalid method, only GET,POST is allowed None
To perform this operation, you must be authenticated by means of one of the following methods: bearerAuth

get__bmc_creds

Code samples

GET https://api-gw-service-nmn.local/apis/scsd/v1/bmc/creds HTTP/1.1
Host: api-gw-service-nmn.local
Accept: application/json

# You can also use wget
curl -X GET https://api-gw-service-nmn.local/apis/scsd/v1/bmc/creds \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api-gw-service-nmn.local/apis/scsd/v1/bmc/creds', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-gw-service-nmn.local/apis/scsd/v1/bmc/creds", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /bmc/creds

Fetch controller login credentials for specified targets and types.

Fetch controller login credentials for a specified targets. Targets are specified as a comma-separated list of xnames. A component type may also be specified. The xname list is ‘ANDed’ with the component type; any xname that has a type other than the specified type will be discarded. If no type is specified, all BMC types are used. If no query parameters are specified at all, all BMCs in the system are used.

Parameters

Name In Type Required Description
targets query xname_list false Comma separated list of XNames. No query string results in fetching creds for all known BMCs.
type query string false Target component type. A maximum of one type is allowed. If no type is specified, all known BMC types are returned.

Example responses

200 Response

[
  {
    "Xname": "x0c0s0b0",
    "Username": "admin",
    "Password": "pwstring",
    "StatusCode": 200,
    "StatusMsg": "OK"
  }
]

Responses

Status Meaning Description Schema
200 OK OK. The data was succesfully set creds_fetch_rsp
404 Not Found Endpoint not found None
405 Method Not Allowed Invalid method, only GET, POST is allowed None
To perform this operation, you must be authenticated by means of one of the following methods: bearerAuth

post__bmc_globalcreds

Code samples

POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/globalcreds HTTP/1.1
Host: api-gw-service-nmn.local
Content-Type: application/json
Accept: application/json

# You can also use wget
curl -X POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/globalcreds \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api-gw-service-nmn.local/apis/scsd/v1/bmc/globalcreds', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-gw-service-nmn.local/apis/scsd/v1/bmc/globalcreds", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /bmc/globalcreds

Set the the same controller login credentials for a set of targets

Set controller login credentials for a set of targets. The POST payload contains the parameters to set along with a list of targets. The same credentials are set on all targets.

The Force field is optional. If present, and set to ’true’, the Redfish operations will be attempted without contacting HSM and without verifying if the targets are present or are in a good state. If the “Force” field is not present or is present but set to ‘false’, HSM will be used.

Body parameter

{
  "Force": true,
  "Username": "string",
  "Password": "string",
  "Targets": [
    "x0c0s0b0"
  ]
}

Parameters

Name In Type Required Description
body body creds_global false none

Example responses

200 Response

{
  "Targets": [
    {
      "Xname": "x0c0s0b0",
      "StatusCode": 200,
      "StatusMsg": "OK"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK. The data was succesfully set multi_post_response
404 Not Found Endpoint not found None
405 Method Not Allowed Invalid method, only POST is allowed None
To perform this operation, you must be authenticated by means of one of the following methods: bearerAuth

bios

Endpoints that set or get BIOS information

get__bmc_bios_{xname}_{bios_field}

Code samples

GET https://api-gw-service-nmn.local/apis/scsd/v1/bmc/bios/{xname}/{bios_field} HTTP/1.1
Host: api-gw-service-nmn.local
Accept: application/json

# You can also use wget
curl -X GET https://api-gw-service-nmn.local/apis/scsd/v1/bmc/bios/{xname}/{bios_field} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api-gw-service-nmn.local/apis/scsd/v1/bmc/bios/{xname}/{bios_field}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-gw-service-nmn.local/apis/scsd/v1/bmc/bios/{xname}/{bios_field}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /bmc/bios/{xname}/{bios_field}

Fetch the current BIOS setting for the TPM State.

Fetch the current BIOS setting for the TPM State.

Parameters

Name In Type Required Description
xname path xname_for_node true Locational xname of BMC.
bios_field path bios_field true Name of the BIOS field

Enumerated Values

Parameter Value
bios_field tpmstate

Example responses

200 Response

{
  "Current": "Enabled",
  "Future": "Enabled"
}

Responses

Status Meaning Description Schema
200 OK OK. bmc_bios_tpm_state
400 Bad Request Bad request. Problem7807
404 Not Found Xname was not for a bmc. Problem7807
500 Internal Server Error Internal server error including failures communicating with the server. Problem7807
To perform this operation, you must be authenticated by means of one of the following methods: bearerAuth

patch__bmc_bios_{xname}_{bios_field}

Code samples

PATCH https://api-gw-service-nmn.local/apis/scsd/v1/bmc/bios/{xname}/{bios_field} HTTP/1.1
Host: api-gw-service-nmn.local
Content-Type: application/json
Accept: application/json

# You can also use wget
curl -X PATCH https://api-gw-service-nmn.local/apis/scsd/v1/bmc/bios/{xname}/{bios_field} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.patch('https://api-gw-service-nmn.local/apis/scsd/v1/bmc/bios/{xname}/{bios_field}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "https://api-gw-service-nmn.local/apis/scsd/v1/bmc/bios/{xname}/{bios_field}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PATCH /bmc/bios/{xname}/{bios_field}

Set the TPM State field in the BIOS settings

Set the TPM State in the BIOS settings.

Body parameter

{
  "Future": "Enabled"
}

Parameters

Name In Type Required Description
xname path xname_for_node true Locational xname of the BMC.
bios_field path bios_field true Name of the BIOS field
body body bmc_bios_tpm_state_put false none

Enumerated Values

Parameter Value
bios_field tpmstate

Example responses

400 Response

{
  "type": "about:blank",
  "detail": "Detail about this specific problem occurrence. See RFC7807",
  "instance": "",
  "status": 400,
  "title": "Description of HTTP Status code, e.g. 400"
}

Responses

Status Meaning Description Schema
204 No Content OK. The value was set. None
400 Bad Request Bad request. Problem7807
404 Not Found Xname was not for a bmc. Problem7807
500 Internal Server Error Internal server error including failures communicating with the server. Problem7807
To perform this operation, you must be authenticated by means of one of the following methods: bearerAuth

version

Endpoints that perform health and version checks

get__version

Code samples

GET https://api-gw-service-nmn.local/apis/scsd/v1/version HTTP/1.1
Host: api-gw-service-nmn.local
Accept: application/json

# You can also use wget
curl -X GET https://api-gw-service-nmn.local/apis/scsd/v1/version \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api-gw-service-nmn.local/apis/scsd/v1/version', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-gw-service-nmn.local/apis/scsd/v1/version", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /version

Retrieve service version information

Retrieve service version information. Version is returned in vmaj.min.bld format

Example responses

200 Response

{
  "Version": "v1.2.3"
}

Responses

Status Meaning Description Schema
200 OK Information retrieved successfully version
404 Not Found Endpoint not found None
405 Method Not Allowed Invalid method, only GET,POST is allowed None
To perform this operation, you must be authenticated by means of one of the following methods: bearerAuth

certs

Endpoints that create, delete, fetch, and apply TLS certs

post__bmc_createcerts

Code samples

POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/createcerts HTTP/1.1
Host: api-gw-service-nmn.local
Content-Type: application/json
Accept: application/json

# You can also use wget
curl -X POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/createcerts \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api-gw-service-nmn.local/apis/scsd/v1/bmc/createcerts', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-gw-service-nmn.local/apis/scsd/v1/bmc/createcerts", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /bmc/createcerts

Create TLS cert/key pairs for a set of targets

Create TLS cert/key pairs for a set of BMC targets. A TLS cert/key is created per BMC ‘domain’, the default being one cert per cabinet to be used by all BMCs in that cabinet. TLS cert/key info is stored in secure storage for subsequent application or viewing.

Body parameter

{
  "Domain": "Cabinet",
  "DomainIDs": [
    "x0c0s0b0"
  ]
}

Parameters

Name In Type Required Description
body body bmc_managecerts_request false none

Example responses

200 Response

{
  "DomainIDs": [
    {
      "ID": "x0c0s0b0",
      "StatusCode": 200,
      "StatusMsg": "OK"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK. The data was succesfully retrieved bmc_managecerts_response
404 Not Found Endpoint not found None
405 Method Not Allowed Invalid method, only POST or DELETE is allowed None
To perform this operation, you must be authenticated by means of one of the following methods: bearerAuth

post__bmc_deletecerts

Code samples

POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/deletecerts HTTP/1.1
Host: api-gw-service-nmn.local
Content-Type: application/json
Accept: application/json

# You can also use wget
curl -X POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/deletecerts \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api-gw-service-nmn.local/apis/scsd/v1/bmc/deletecerts', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-gw-service-nmn.local/apis/scsd/v1/bmc/deletecerts", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /bmc/deletecerts

Delete TLS cert/key pairs for a set of targets

Delete TLS cert/key information for domain-level TLS certs based on the given targets. There will be one TLS cert/key per BMC ‘domain’ which will be deleted from secure storage.

Body parameter

{
  "Domain": "Cabinet",
  "DomainIDs": [
    "x0c0s0b0"
  ]
}

Parameters

Name In Type Required Description
body body bmc_managecerts_request false none

Example responses

200 Response

{
  "DomainIDs": [
    {
      "ID": "x0c0s0b0",
      "StatusCode": 200,
      "StatusMsg": "OK"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK. The data was succesfully retrieved bmc_managecerts_response
404 Not Found Endpoint not found None
405 Method Not Allowed Invalid method, only POST or DELETE is allowed None
To perform this operation, you must be authenticated by means of one of the following methods: bearerAuth

post__bmc_fetchcerts

Code samples

POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/fetchcerts HTTP/1.1
Host: api-gw-service-nmn.local
Content-Type: application/json
Accept: application/json

# You can also use wget
curl -X POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/fetchcerts \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api-gw-service-nmn.local/apis/scsd/v1/bmc/fetchcerts', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-gw-service-nmn.local/apis/scsd/v1/bmc/fetchcerts", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /bmc/fetchcerts

Fetch previously created BMC TLS certs for viewing.

Fetches BMC TLS certs previously created using the /bmc/createcerts endpoint and stored in secure storage. This API does not interact with Redfish BMCs.

Body parameter

{
  "Domain": "Cabinet",
  "DomainIDs": [
    "x0c0s0b0"
  ]
}

Parameters

Name In Type Required Description
body body bmc_managecerts_request false none

Example responses

200 Response

{
  "DomainIDs": [
    {
      "ID": "x0c0s0b0",
      "StatusCode": 200,
      "StatusMsg": "OK",
      "Cert": {
        "CertType": "PEM",
        "CertData": "-----BEGIN CERTIFICATE-----...-----END CERTIFICATE-----"
      }
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK. The data was succesfully retrieved bmc_fetchcerts_response
404 Not Found Endpoint not found None
405 Method Not Allowed Invalid method, only POST is allowed None
To perform this operation, you must be authenticated by means of one of the following methods: bearerAuth

post__bmc_setcerts

Code samples

POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/setcerts HTTP/1.1
Host: api-gw-service-nmn.local
Content-Type: application/json
Accept: application/json

# You can also use wget
curl -X POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/setcerts \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api-gw-service-nmn.local/apis/scsd/v1/bmc/setcerts', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-gw-service-nmn.local/apis/scsd/v1/bmc/setcerts", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /bmc/setcerts

Apply previously-generated TLS cert/key data to target BMCs

Apply TLS cert/key pairs, previously generated using the /bmc/createcerts endpoint, to target BMCs. The Force field is optional. If present, and set to ’true’, the Redfish operations will be attempted without contacting HSM and without verifying if the targets are present or are in a good state. If the “Force” field is not present or is present but set to ‘false’, HSM will be used.

Body parameter

{
  "Force": false,
  "CertDomain": "Cabinet",
  "Targets": [
    "x0c0s0b0"
  ]
}

Parameters

Name In Type Required Description
body body bmc_rfcerts_request false none

Example responses

200 Response

{
  "Targets": [
    {
      "ID": "x0c0s0b0",
      "StatusCode": 200,
      "StatusMsg": "OK"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK. The data was succesfully retrieved bmc_rfcerts_response
404 Not Found Endpoint not found None
405 Method Not Allowed Invalid method, only POST is allowed None
To perform this operation, you must be authenticated by means of one of the following methods: bearerAuth

post__bmc_setcert_{xname}

Code samples

POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/setcert/{xname} HTTP/1.1
Host: api-gw-service-nmn.local

# You can also use wget
curl -X POST https://api-gw-service-nmn.local/apis/scsd/v1/bmc/setcert/{xname} \
  -H 'Authorization: Bearer {access-token}'

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api-gw-service-nmn.local/apis/scsd/v1/bmc/setcert/{xname}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-gw-service-nmn.local/apis/scsd/v1/bmc/setcert/{xname}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /bmc/setcert/{xname}

Apply previously-generated TLS cert/key data to the target BMC

Apply a TLS cert/key pairs previously generated using the /bmc/createcerts endpoint to the target BMC. The Force parameter is optional. If present, and set to ’true’, the Redfish operations will be attempted without contacting HSM and without verifying if the targets are present or are in a good state. If the “Force” parameter is not present or is present but set to ‘false’, HSM will be used.

Parameters

Name In Type Required Description
xname path xname true none
Force query boolean false If true do not verify xname with HSM
Domain query string false none

Responses

Status Meaning Description Schema
200 OK OK. The cert was succesfully applied to BMC target None
404 Not Found Endpoint not found None
405 Method Not Allowed Invalid method, only POST is allowed None
To perform this operation, you must be authenticated by means of one of the following methods: bearerAuth

cli_ignore

get__liveness

Code samples

GET https://api-gw-service-nmn.local/apis/scsd/v1/liveness HTTP/1.1
Host: api-gw-service-nmn.local

# You can also use wget
curl -X GET https://api-gw-service-nmn.local/apis/scsd/v1/liveness \
  -H 'Authorization: Bearer {access-token}'

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api-gw-service-nmn.local/apis/scsd/v1/liveness', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-gw-service-nmn.local/apis/scsd/v1/liveness", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /liveness

Get liveness status of the service

Get liveness status of the service

Responses

Status Meaning Description Schema
204 No Content No Content Network API call success None
503 Service Unavailable The service is not taking HTTP requests None
To perform this operation, you must be authenticated by means of one of the following methods: bearerAuth

get__readiness

Code samples

GET https://api-gw-service-nmn.local/apis/scsd/v1/readiness HTTP/1.1
Host: api-gw-service-nmn.local

# You can also use wget
curl -X GET https://api-gw-service-nmn.local/apis/scsd/v1/readiness \
  -H 'Authorization: Bearer {access-token}'

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api-gw-service-nmn.local/apis/scsd/v1/readiness', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-gw-service-nmn.local/apis/scsd/v1/readiness", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /readiness

Get readiness status of the service

Get readiness status of the service

Responses

Status Meaning Description Schema
200 OK No Content Network API call success None
503 Service Unavailable The service is not taking HTTP requests None
To perform this operation, you must be authenticated by means of one of the following methods: bearerAuth

get__health

Code samples

GET https://api-gw-service-nmn.local/apis/scsd/v1/health HTTP/1.1
Host: api-gw-service-nmn.local
Accept: application/json

# You can also use wget
curl -X GET https://api-gw-service-nmn.local/apis/scsd/v1/health \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api-gw-service-nmn.local/apis/scsd/v1/health', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-gw-service-nmn.local/apis/scsd/v1/health", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /health

Get readiness status of the service

Get readiness status of the service

Example responses

200 Response

{
  "TaskRunnerStatus": "OK",
  "TaskRunnerMode": "Local",
  "VaultStatus": "Connected"
}

Responses

Status Meaning Description Schema
200 OK OK. All health parameters are operational. health
500 Internal Server Error The service encountered an error when gathering health information None
503 Service Unavailable The service is not taking HTTP requests None
To perform this operation, you must be authenticated by means of one of the following methods: bearerAuth

Schemas

xname

"x0c0s0b0"

The xname of this piece of hardware

Properties

Name Type Required Restrictions Description
anonymous string false none The xname of this piece of hardware

xname_for_node

"x0c0s0b0n0"

The xname of this piece of hardware

Properties

Name Type Required Restrictions Description
anonymous string false none The xname of this piece of hardware

xname_list

"x1000c0s0b0,x1000c0s1b0"

Comma separated list of xnames

Properties

Name Type Required Restrictions Description
anonymous string false none Comma separated list of xnames

bios_field

"tpmstate"

The name of the BIOS field

Properties

Name Type Required Restrictions Description
anonymous string false none The name of the BIOS field

Enumerated Values

Property Value
anonymous tpmstate

ntp_server_info_kw

"NTPServerInfo"

NTP server

Properties

Name Type Required Restrictions Description
anonymous string false none NTP server

syslog_server_info_kw

"SyslogServerInfo"

Syslog server

Properties

Name Type Required Restrictions Description
anonymous string false none Syslog server

sshkey_kw

"SSHKey"

SSH key

Properties

Name Type Required Restrictions Description
anonymous string false none SSH key

sshconkey_kw

"SSHConsoleKey"

SSH console key

Properties

Name Type Required Restrictions Description
anonymous string false none SSH console key

cfg_types

"NTPServerInfo"

Redfish Network Protocol parameter names

Properties

Name Type Required Restrictions Description
anonymous string false none Redfish Network Protocol parameter names

target_ntp_server

{
  "NTPServers": "sms-ncn-w001",
  "Port": 0,
  "ProtocolEnabled": true
}

Properties

Name Type Required Restrictions Description
NTPServers string false none NTP service server name
Port integer false none none
ProtocolEnabled boolean false none none

target_syslog_server

{
  "SyslogServers": "sms-ncn-w001",
  "Port": 0,
  "ProtocolEnabled": true
}

Properties

Name Type Required Restrictions Description
SyslogServers string false none Syslog service server name
Port integer false none none
ProtocolEnabled boolean false none none

target_ssh_key

"xyzabc123..."

Properties

Name Type Required Restrictions Description
anonymous string false none none

params

{
  "NTPServerInfo": {
    "NTPServers": "sms-ncn-w001",
    "Port": 0,
    "ProtocolEnabled": true
  },
  "SyslogServerInfo": {
    "SyslogServers": "sms-ncn-w001",
    "Port": 0,
    "ProtocolEnabled": true
  },
  "SSHKey": "xyzabc123...",
  "SSHConsoleKey": "xyzabc123..."
}

Properties

Name Type Required Restrictions Description
NTPServerInfo target_ntp_server false none none
SyslogServerInfo target_syslog_server false none none
SSHKey target_ssh_key false none none
SSHConsoleKey target_ssh_key false none none

target_cfg_item

{
  "StatusCode": 0,
  "StatusMsg": "string",
  "Xname": "x0c0s0b0",
  "Params": {
    "NTPServerInfo": {
      "NTPServers": "sms-ncn-w001",
      "Port": 0,
      "ProtocolEnabled": true
    },
    "SyslogServerInfo": {
      "SyslogServers": "sms-ncn-w001",
      "Port": 0,
      "ProtocolEnabled": true
    },
    "SSHKey": "xyzabc123...",
    "SSHConsoleKey": "xyzabc123..."
  }
}

Properties

Name Type Required Restrictions Description
StatusCode integer true none none
StatusMsg string true none none
Xname xname true none The xname of this piece of hardware
Params params false none none

cfg_get_single

{
  "Force": true,
  "Params": {
    "NTPServerInfo": {
      "NTPServers": "sms-ncn-w001",
      "Port": 0,
      "ProtocolEnabled": true
    },
    "SyslogServerInfo": {
      "SyslogServers": "sms-ncn-w001",
      "Port": 0,
      "ProtocolEnabled": true
    },
    "SSHKey": "xyzabc123...",
    "SSHConsoleKey": "xyzabc123..."
  }
}

Properties

Name Type Required Restrictions Description
Force boolean false none none
Params params false none none

cfg_post_single

{
  "Force": true,
  "Params": {
    "NTPServerInfo": {
      "NTPServers": "sms-ncn-w001",
      "Port": 0,
      "ProtocolEnabled": true
    },
    "SyslogServerInfo": {
      "SyslogServers": "sms-ncn-w001",
      "Port": 0,
      "ProtocolEnabled": true
    },
    "SSHKey": "xyzabc123...",
    "SSHConsoleKey": "xyzabc123..."
  }
}

Properties

Name Type Required Restrictions Description
Force boolean false none none
Params params false none none

cfg_rsp_status

{
  "StatusMsg": "OK"
}

Properties

Name Type Required Restrictions Description
StatusMsg string false none none

bmc_dumpcfg_request

{
  "Targets": [
    "x0c0s0b0"
  ],
  "Params": [
    "NTPServerInfo"
  ]
}

Properties

Name Type Required Restrictions Description
Targets [xname] true none [The xname of this piece of hardware]
Params [cfg_types] false none [Redfish Network Protocol parameter names]

multi_post_response_elem

{
  "Xname": "x0c0s0b0",
  "StatusCode": 200,
  "StatusMsg": "OK"
}

Properties

Name Type Required Restrictions Description
Xname xname false none The xname of this piece of hardware
StatusCode integer false none none
StatusMsg string false none none

multi_post_response

{
  "Targets": [
    {
      "Xname": "x0c0s0b0",
      "StatusCode": 200,
      "StatusMsg": "OK"
    }
  ]
}

Properties

Name Type Required Restrictions Description
Targets [multi_post_response_elem] false none none

bmc_dumpcfg_response

{
  "Targets": [
    {
      "StatusCode": 0,
      "StatusMsg": "string",
      "Xname": "x0c0s0b0",
      "Params": {
        "NTPServerInfo": {
          "NTPServers": "sms-ncn-w001",
          "Port": 0,
          "ProtocolEnabled": true
        },
        "SyslogServerInfo": {
          "SyslogServers": "sms-ncn-w001",
          "Port": 0,
          "ProtocolEnabled": true
        },
        "SSHKey": "xyzabc123...",
        "SSHConsoleKey": "xyzabc123..."
      }
    }
  ]
}

Properties

Name Type Required Restrictions Description
Targets [target_cfg_item] false none none

bmc_loadcfg_request

{
  "Force": true,
  "Targets": [
    "x0c0s0b0"
  ],
  "Params": {
    "NTPServer": {
      "NTPServers": "sms-ncn-w001",
      "Port": 0,
      "ProtocolEnabled": true
    },
    "SyslogServer": {
      "SyslogServers": "sms-ncn-w001",
      "Port": 0,
      "ProtocolEnabled": true
    },
    "SSHKey": "xyzabc123...",
    "SSHConsoleKey": "xyzabc123..."
  }
}

Properties

Name Type Required Restrictions Description
Force boolean false none none
Targets [xname] true none [The xname of this piece of hardware]
Params object false none none
» NTPServer target_ntp_server false none none
» SyslogServer target_syslog_server false none none
» SSHKey target_ssh_key false none none
» SSHConsoleKey target_ssh_key false none none

creds_data

{
  "Username": "admin-user",
  "Password": "admin-pw"
}

Properties

Name Type Required Restrictions Description
Username string false none none
Password string false none none

creds_target

{
  "Xname": "x0c0s0b0",
  "Creds": {
    "Username": "admin-user",
    "Password": "admin-pw"
  }
}

Properties

Name Type Required Restrictions Description
Xname xname false none The xname of this piece of hardware
Creds creds_data false none none

creds_components

{
  "Force": true,
  "Targets": [
    {
      "Xname": "x0c0s0b0",
      "Creds": {
        "Username": "admin-user",
        "Password": "admin-pw"
      }
    }
  ]
}

Properties

Name Type Required Restrictions Description
Force boolean false none none
Targets [creds_target] false none none

creds_single

{
  "Force": true,
  "Creds": {
    "Username": "admin-user",
    "Password": "admin-pw"
  }
}

Properties

Name Type Required Restrictions Description
Force boolean false none none
Creds creds_data false none none

creds_global

{
  "Force": true,
  "Username": "string",
  "Password": "string",
  "Targets": [
    "x0c0s0b0"
  ]
}

Properties

Name Type Required Restrictions Description
Force boolean false none none
Username string false none none
Password string false none none
Targets [xname] false none [The xname of this piece of hardware]

creds_fetch_rsp

[
  {
    "Xname": "x0c0s0b0",
    "Username": "admin",
    "Password": "pwstring",
    "StatusCode": 200,
    "StatusMsg": "OK"
  }
]

Properties

Name Type Required Restrictions Description
anonymous [creds_fetch_rsp_elmt] false none none

creds_fetch_rsp_elmt

{
  "Xname": "x0c0s0b0",
  "Username": "admin",
  "Password": "pwstring",
  "StatusCode": 200,
  "StatusMsg": "OK"
}

Properties

Name Type Required Restrictions Description
Xname xname false none The xname of this piece of hardware
Username string false none none
Password string false none none
StatusCode integer false none none
StatusMsg string false none none

bmc_managecerts_request

{
  "Domain": "Cabinet",
  "DomainIDs": [
    "x0c0s0b0"
  ]
}

Properties

Name Type Required Restrictions Description
Domain string false none none
DomainIDs [xname] false none [The xname of this piece of hardware]

bmc_managecerts_response

{
  "DomainIDs": [
    {
      "ID": "x0c0s0b0",
      "StatusCode": 200,
      "StatusMsg": "OK"
    }
  ]
}

Properties

Name Type Required Restrictions Description
DomainIDs [cert_rsp] false none none

bmc_fetchcerts_response

{
  "DomainIDs": [
    {
      "ID": "x0c0s0b0",
      "StatusCode": 200,
      "StatusMsg": "OK",
      "Cert": {
        "CertType": "PEM",
        "CertData": "-----BEGIN CERTIFICATE-----...-----END CERTIFICATE-----"
      }
    }
  ]
}

Properties

Name Type Required Restrictions Description
DomainIDs [cert_rsp_with_cert] false none none

cert_rsp

{
  "ID": "x0c0s0b0",
  "StatusCode": 200,
  "StatusMsg": "OK"
}

Properties

Name Type Required Restrictions Description
ID xname false none The xname of this piece of hardware
StatusCode integer false none none
StatusMsg string false none none

cert_rsp_with_cert

{
  "ID": "x0c0s0b0",
  "StatusCode": 200,
  "StatusMsg": "OK",
  "Cert": {
    "CertType": "PEM",
    "CertData": "-----BEGIN CERTIFICATE-----...-----END CERTIFICATE-----"
  }
}

Properties

Name Type Required Restrictions Description
ID xname false none The xname of this piece of hardware
StatusCode integer false none none
StatusMsg string false none none
Cert object false none none
» CertType string false none none
» CertData string false none none

bmc_rfcerts_request

{
  "Force": false,
  "CertDomain": "Cabinet",
  "Targets": [
    "x0c0s0b0"
  ]
}

Properties

Name Type Required Restrictions Description
Force boolean false none none
CertDomain string false none none
Targets [xname] false none [The xname of this piece of hardware]

bmc_rfcerts_response

{
  "Targets": [
    {
      "ID": "x0c0s0b0",
      "StatusCode": 200,
      "StatusMsg": "OK"
    }
  ]
}

Properties

Name Type Required Restrictions Description
Targets [cert_rsp] false none none

bmc_bios_tpm_state

{
  "Current": "Enabled",
  "Future": "Enabled"
}

Properties

Name Type Required Restrictions Description
Current string false none The current BIOS setting
Future string false none The future BIOS setting which will take affect when the node is rebooted

Enumerated Values

Property Value
Current Disabled
Current Enabled
Current NotPresent
Future Disabled
Future Enabled
Future NotPresent

bmc_bios_tpm_state_put

{
  "Future": "Enabled"
}

Properties

Name Type Required Restrictions Description
Future string false none The future BIOS setting which will take affect when the node is rebooted

Enumerated Values

Property Value
Future Disabled
Future Enabled

version

{
  "Version": "v1.2.3"
}

Properties

Name Type Required Restrictions Description
Version string false none none

health

{
  "TaskRunnerStatus": "OK",
  "TaskRunnerMode": "Local",
  "VaultStatus": "Connected"
}

Properties

Name Type Required Restrictions Description
TaskRunnerStatus string false none none
TaskRunnerMode string false none none
VaultStatus string false none none

Enumerated Values

Property Value
TaskRunnerMode Local
TaskRunnerMode Worker

Problem7807

{
  "type": "about:blank",
  "detail": "Detail about this specific problem occurrence. See RFC7807",
  "instance": "",
  "status": 400,
  "title": "Description of HTTP Status code, e.g. 400"
}

RFC 7807 compliant error payload. All fields are optional except the ’type’ field.

Properties

Name Type Required Restrictions Description
type string true none none
detail string false none none
instance string false none none
status number(int32) false none none
title string false none none