Mender

https://docs.mender.io
Admin
Mender is an open-source over-the-air software updater for connected Linux devices, enabling secure...
Tokens:1,820,372
Snippets:23,601
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install Examples Package

Source: https://docs.mender.io/3.7/downloads

Extract the downloaded tarball to the root directory.

```bash
sudo tar -C / --strip-components=2 -xvf mender-gateway-examples-1.2.0.tarcopy
```

--------------------------------

### Example output of provides command

Source: https://docs.mender.io/3.7/artifact-creation/software-versioning

Displays the checksum and versioning information for the installed rootfs-image.

```text
rootfs-image.checksum=539fb70abbe1c680816c846219cef7cd409c96f130f652734e4bcfa5dd825dd3
rootfs-image.version=1.0.0copy
```

--------------------------------

### Install Mender Gateway Examples

Source: https://docs.mender.io/3.6/downloads

Extract the downloaded tarball to the root directory.

```bash
sudo tar -C / --strip-components=2 -xvf mender-gateway-examples-1.1.0.tarcopy
```

--------------------------------

### Inspect installed versions

Source: https://docs.mender.io/3.7/artifact-creation/software-versioning

Example output showing the updated versioning key alongside standard rootfs-image metadata.

```text
data-partition.myapp.version=v2020.10
rootfs-image.checksum=539fb70abbe1c680816c846219cef7cd409c96f130f652734e4bcfa5dd825dd3
rootfs-image.version=1.0.0
```

--------------------------------

### Run Demo server setup

Source: https://docs.mender.io/client-installation/install-with-debian-package

Execute the setup command with Demo server specific flags.

```bash
sudo mender-setup \
            --device-type $DEVICE_TYPE \
            --demo-server \
            --server-ip $SERVER_IP_ADDR \
            --demo-polling
```

--------------------------------

### Get device details response examples

Source: https://docs.mender.io/1.0/apis/management-apis/device-admission

Example HTTP responses for the get device details endpoint.

```json
{
  "id" : "291ae0e5956c69c2267489213df4459d19ed48a806603def19d417d004a4b67e",
  "device_identity" : "{\"mac\":\"00:01:02:03:04:05\", \"sku\":\"My Device 1\", \"sn\":\"SN1234567890\"}",
  "key" : "-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzogVU7RGDilbsoUt/DdH
VJvcepl0A5+xzGQ50cq1VE/Dyyy8Zp0jzRXCnnu9nu395mAFSZGotZVr+sWEpO3c
yC3VmXdBZmXmQdZqbdD/GuixJOYfqta2ytbIUPRXFN7/I7sgzxnXWBYXYmObYvdP
okP0mQanY+WKxp7Q16pt1RoqoAd0kmV39g13rFl35muSHbSBoAW3GBF3gO+mF5Ty
1ddp/XcgLOsmvNNjY+2HOD5F/RX0fs07mWnbD7x+xz7KEKjF+H7ZpkqCwmwCXaf0
iyYyh1852rti3Afw4mDxuVSD7sd9ggvYMc0QHIpQNkD4YWOhNiE1AB0zH57VbUYG
UwIDAQAB
-----END PUBLIC KEY-----
",
  "status" : "pending",
  "attributes" : {
    "mac" : "00:01:02:03:04:05",
    "sku" : "My Device 1",
    "sn" : "SN1234567890"
  },
  "request_time" : "2016-10-03T16:58:51.639Z"
}
```

```json
{
  "error" : "failed to decode device group data: JSON payload is empty",
  "request_id" : "f7881e82-0492-49fb-b459-795654e7188a"
}
```

```json
{
  "error" : "failed to decode device group data: JSON payload is empty",
  "request_id" : "f7881e82-0492-49fb-b459-795654e7188a"
}
```

--------------------------------

### Mender-convert installation output

Source: https://docs.mender.io/operating-system-updates-debian-family/customize-mender/mender-monitor-support

Example log output showing the successful installation of the mender-monitor package.

```text
2024-06-19 13:10:34 [INFO] [mender-convert-modify] Installing input/deb/mender-monitor.deb
2024-06-19 13:10:34 [INFO] [mender-convert-modify] Installing dependencies for mender-convert/input/deb/mender-monitor.deb
```

--------------------------------

### Get User Information Responses

Source: https://docs.mender.io/1.2/apis/management-apis/user-administration-and-authentication

Example JSON responses for GET /users/{id} requests.

```json
{
  "email" : "user@acme.com",
  "id" : "806603def19d417d004a4b67e",
  "created_ts" : "2016-10-03T16:58:51.639Z",
  "updated_ts" : "2016-10-04T11:33:66.611Z"
}
```

```json
{
  "error" : "missing Authorization header",
  "request_id" : "f7881e82-0492-49fb-b459-795654e7188a"
}
```

--------------------------------

### Configure Demo Server Client

Source: https://docs.mender.io/3.6/client-installation/install-with-debian-package

Run the setup command for a Demo server environment using the previously defined variables.

```bash
sudo mender setup \
            --device-type $DEVICE_TYPE \
            --demo-server \
            --server-ip $SERVER_IP_ADDR \
            --demo-polling
```

--------------------------------

### Get Device Limit API Request

Source: https://docs.mender.io/3.6/server-side-api

Examples of how to perform a GET request to retrieve the maximum device limit.

```shell
curl -X GET https://hosted.mender.io/api/management/v2/devauth/limits/max_devices \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'
```

```http
GET https://hosted.mender.io/api/management/v2/devauth/limits/max_devices HTTP/1.1
Host: hosted.mender.io
Accept: application/json
```

```javascript
const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://hosted.mender.io/api/management/v2/devauth/limits/max_devices',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
```

```ruby
require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://hosted.mender.io/api/management/v2/devauth/limits/max_devices',
  params: {
  }, headers: headers

p JSON.parse(result)
```

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

r = requests.get('https://hosted.mender.io/api/management/v2/devauth/limits/max_devices', headers = headers)

print(r.json())
```

```php
<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://hosted.mender.io/api/management/v2/devauth/limits/max_devices', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...
```

```java
URL obj = new URL("https://hosted.mender.io/api/management/v2/devauth/limits/max_devices");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
```

```go
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://hosted.mender.io/api/management/v2/devauth/limits/max_devices", data)
    req.Header = headers

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

--------------------------------

### Prepare installation directory

Source: https://docs.mender.io/2.1/devices/update-modules

Create the target directory on the device where files will be copied.

```bash
mkdir -p /var/www
```

--------------------------------

### Integrate Examples Package

Source: https://docs.mender.io/operating-system-updates-yocto-project/customize-mender

Add the demo layer and append the examples package to the gateway sources for testing purposes.

```bash
bitbake-layers add-layer ../sources/meta-mender/meta-mender-demo
```

```bitbake
SRC_URI:pn-mender-gateway:append = " file:///${HOME}/mender-gateway-examples-2.1.0.tar"
```

--------------------------------

### Install dependencies for update flow control

Source: https://docs.mender.io/3.6/client-installation/use-the-device-side-api

Install required system packages on Debian-based systems before running the example application.

```bash
sudo apt-get update
sudo apt-get install -y git python3 python3-pipcopy
```

--------------------------------

### Get Authentication Status Request Examples

Source: https://docs.mender.io/api/v4.0

Various ways to perform a GET request to retrieve device authentication status.

```shell
curl -X GET https://hosted.mender.io/api/management/v2/devauth/devices/{id}/auth/{aid}/status \
  -H 'Accept: application/json' \
  -H 'X-MEN-RequestID: string' \
  -H 'Authorization: Bearer {access-token}'
```

```http
GET https://hosted.mender.io/api/management/v2/devauth/devices/{id}/auth/{aid}/status HTTP/1.1
Host: hosted.mender.io
Accept: application/json
X-MEN-RequestID: string
```

```javascript
const headers = {
  'Accept':'application/json',
  'X-MEN-RequestID':'string',
  'Authorization':'Bearer {access-token}'
};

fetch('https://hosted.mender.io/api/management/v2/devauth/devices/{id}/auth/{aid}/status',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
```

```ruby
require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-MEN-RequestID' => 'string',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://hosted.mender.io/api/management/v2/devauth/devices/{id}/auth/{aid}/status',
  params: {
  }, headers: headers

p JSON.parse(result)
```

```python
import requests
headers = {
  'Accept': 'application/json',
  'X-MEN-RequestID': 'string',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://hosted.mender.io/api/management/v2/devauth/devices/{id}/auth/{aid}/status', headers = headers)

print(r.json())
```

```php
<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'X-MEN-RequestID' => 'string',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://hosted.mender.io/api/management/v2/devauth/devices/{id}/auth/{aid}/status', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...
```

```java
URL obj = new URL("https://hosted.mender.io/api/management/v2/devauth/devices/{id}/auth/{aid}/status");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
```

```go
package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hosted.mender.io/api/management/v2/devauth/devices/{id}/auth/{aid}/status", data)
    req.Header = headers

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

--------------------------------

### Deploy Configuration via Go

Source: https://docs.mender.io/3.6/server-side-api

Example using the net/http package to perform the POST request.

```go
package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://mender-deviceconfig:8080/api/internal/v1/deviceconfig/tenants/{tenantId}/configurations/device/{deviceId}/deploy", data)
    req.Header = headers

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

--------------------------------

### Get Device License Request Examples

Source: https://docs.mender.io/3.6/server-side-api

Examples of how to retrieve device license information using different programming languages and tools.

```bash
# You can also use wget
curl -X GET https://hosted.mender.io/api/management/v2/devauth/license \
  -H 'Accept: text/csv' \
  -H 'Authorization: Bearer {access-token}'
```

```http
GET https://hosted.mender.io/api/management/v2/devauth/license HTTP/1.1
Host: hosted.mender.io
Accept: text/csv
```

```javascript
const headers = {
  'Accept':'text/csv',
  'Authorization':'Bearer {access-token}'
};

fetch('https://hosted.mender.io/api/management/v2/devauth/license',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
```

```ruby
require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/csv',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://hosted.mender.io/api/management/v2/devauth/license',
  params: {
  }, headers: headers

p JSON.parse(result)
```

```python
import requests
headers = {
  'Accept': 'text/csv',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://hosted.mender.io/api/management/v2/devauth/license', headers = headers)

print(r.json())
```

```php
<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'text/csv',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://hosted.mender.io/api/management/v2/devauth/license', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...
```

```java
URL obj = new URL("https://hosted.mender.io/api/management/v2/devauth/license");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
```

```go
package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hosted.mender.io/api/management/v2/devauth/license", data)
    req.Header = headers

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

--------------------------------

### Run Enterprise server setup

Source: https://docs.mender.io/client-installation/install-with-debian-package

Execute the setup command with Enterprise server specific flags.

```bash
sudo mender-setup \
            --device-type $DEVICE_TYPE \
            --server-url $SERVER_URL \
            --server-cert="" \
            --tenant-token $TENANT_TOKEN \
            --demo-polling
```

--------------------------------

### Get device group response examples

Source: https://docs.mender.io/2.1/apis/management-apis/device-inventory

Example JSON responses for group retrieval, including success, not found, and server error.

```json
{
  "group" : "testing"
}
```

```json
{
  "error" : "failed to decode device group data: JSON payload is empty",
  "request_id" : "f7881e82-0492-49fb-b459-795654e7188a"
}
```

--------------------------------

### Get selected device response examples

Source: https://docs.mender.io/1.0/apis/management-apis/device-inventory

Example responses for retrieving a single device, including success, not found, and error states.

```json
{
  "id" : "291ae0e5956c69c2267489213df4459d19ed48a806603def19d417d004a4b67e",
  "attributes" : [ {
    "name" : "ip_addr",
    "value" : "1.2.3.4",
    "description" : "IP address"
  }, {
    "name" : "mac_addr",
    "value" : "00.01:02:03:04:05",
    "description" : "MAC address"
  }, {
    "name" : "ports",
    "value" : [ "8080", "8081" ],
    "description" : "Open ports"
  } ],
  "updated_ts" : "2016-10-03T16:58:51.639Z"
}
```

```json
{
  "error" : "failed to decode device group data: JSON payload is empty",
  "request_id" : "f7881e82-0492-49fb-b459-795654e7188a"
}
```

--------------------------------

### Configure U-Boot for UBI Booting

Source: https://docs.mender.io/1.2/devices/raw-flash

Example U-Boot environment configuration for setting up UBI arguments and the boot sequence using the mender_setup script.

```text
"set_ubiargs=setenv ubiargs ubi.mtd=${mender_mtd_ubi_dev_name} "      \
             "root=${mender_kernel_root} rootfstype=ubifs ubi.fm_autoconvert=1\0"  \
"ubiboot=" \
    "echo Booting from NOR...; "                              \
    "run mender_setup; "                                      \
    "run set_ubiargs; "                                       \
    "ubi part ${mender_mtd_ubi_dev_name} && "                 \
    "ubifsmount ${mender_uboot_root_name} && "                \
    "ubifsload ${kernel_addr_r} /boot/zImage && "             \
    ...copy
```

--------------------------------

### Initialize configuration files

Source: https://docs.mender.io/get-started/preparation/prepare-a-raspberry-pi-device

Creates the necessary empty files on the boot partition to enable SSH and cloud-init.

```bash
touch $RPI_BOOT/ssh $RPI_BOOT/meta-data $RPI_BOOT/user-data
```

--------------------------------

### Get Device Group Request Examples

Source: https://docs.mender.io/api/2.7

Examples for retrieving a device's group using various HTTP clients and programming languages.

```shell
curl -X GET https://hosted.mender.io/api/management/v1/inventory/devices/{id}/group \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'
```

```http
GET https://hosted.mender.io/api/management/v1/inventory/devices/{id}/group HTTP/1.1
Host: hosted.mender.io
Accept: application/json
```

```javascript
const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('https://hosted.mender.io/api/management/v1/inventory/devices/{id}/group',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
```

```ruby
require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'https://hosted.mender.io/api/management/v1/inventory/devices/{id}/group',
  params: {
  }, headers: headers

p JSON.parse(result)
```

```python
import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('https://hosted.mender.io/api/management/v1/inventory/devices/{id}/group', headers = headers)

print(r.json())
```

```php
<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'API_KEY',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://hosted.mender.io/api/management/v1/inventory/devices/{id}/group', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...
```

```java
URL obj = new URL("https://hosted.mender.io/api/management/v1/inventory/devices/{id}/group");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
```

```go
package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hosted.mender.io/api/management/v1/inventory/devices/{id}/group", data)
    req.Header = headers

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

--------------------------------

### Initialize Device via Go

Source: https://docs.mender.io/api/2.7

Uses the net/http package to construct and execute a POST request.

```go
package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://mender-inventory:8080/api/internal/v1/inventory/devices", data)
    req.Header = headers

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

--------------------------------

### Get Storage Usage API Requests

Source: https://docs.mender.io/3.6/server-side-api

Examples of how to perform a GET request to the storage limits endpoint using various programming languages and tools.

```shell
# You can also use wget
curl -X GET https://hosted.mender.io/api/management/v1/deployments/limits/storage \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'
```

```http
GET https://hosted.mender.io/api/management/v1/deployments/limits/storage HTTP/1.1
Host: hosted.mender.io
Accept: application/json
```

```javascript
const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://hosted.mender.io/api/management/v1/deployments/limits/storage',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
```

```ruby
require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://hosted.mender.io/api/management/v1/deployments/limits/storage',
  params: {
  }, headers: headers

p JSON.parse(result)
```

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

r = requests.get('https://hosted.mender.io/api/management/v1/deployments/limits/storage', headers = headers)

print(r.json())
```

```php
<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://hosted.mender.io/api/management/v1/deployments/limits/storage', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...
```

```java
URL obj = new URL("https://hosted.mender.io/api/management/v1/deployments/limits/storage");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
```

```go
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://hosted.mender.io/api/management/v1/deployments/limits/storage", data)
    req.Header = headers

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

--------------------------------

### Deployment Creation Order Example

Source: https://docs.mender.io/3.6/overview/deployment

Sequence of deployment creation commands for dynamic groups.

```text
(1.) Deploy v2 to group-v1
(2.) Deploy v3 to group-v2
```

```text
(1.) Deploy v3 to group-v2
(2.) Deploy v2 to group-v1
```

--------------------------------

### Example provides output

Source: https://docs.mender.io/3.6/artifact-creation/software-versioning

Sample output showing the updated rootfs-image.version field.

```text
rootfs-image.checksum=539fb70abbe1c680816c846219cef7cd409c96f130f652734e4bcfa5dd825dd3
rootfs-image.version=1.0.0
```

--------------------------------

### Provision Tenant via Go

Source: https://docs.mender.io/3.6/server-side-api

Example using the net/http package to provision a new tenant.

```go
package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://mender-device-auth:8080/api/internal/v1/devauth/tenants", data)
    req.Header = headers

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

--------------------------------

### Get Delta Generation Status API Requests

Source: https://docs.mender.io/3.7/server-side-api

Examples of how to perform a GET request to retrieve delta generation status using various tools and programming languages.

```shell
# You can also use wget
curl -X GET https://hosted.mender.io/api/management/v1/deployments/deployments/{deployment_id}/devices/{device_id}/delta/status \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'
```

```http
GET https://hosted.mender.io/api/management/v1/deployments/deployments/{deployment_id}/devices/{device_id}/delta/status HTTP/1.1
Host: hosted.mender.io
Accept: application/json
```

```javascript
const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://hosted.mender.io/api/management/v1/deployments/deployments/{deployment_id}/devices/{device_id}/delta/status',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});
```

```ruby
require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://hosted.mender.io/api/management/v1/deployments/deployments/{deployment_id}/devices/{device_id}/delta/status',
  params: {
  }, headers: headers

p JSON.parse(result)
```

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

r = requests.get('https://hosted.mender.io/api/management/v1/deployments/deployments/{deployment_id}/devices/{device_id}/delta/status', headers = headers)

print(r.json())
```

```php
<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://hosted.mender.io/api/management/v1/deployments/deployments/{deployment_id}/devices/{device_id}/delta/status', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...
```

```java
URL obj = new URL("https://hosted.mender.io/api/management/v1/deployments/deployments/{deployment_id}/devices/{device_id}/delta/status");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());
```

```go
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://hosted.mender.io/api/management/v1/deployments/deployments/{deployment_id}/devices/{device_id}/delta/status", data)
    req.Header = headers

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

--------------------------------

### Create Deployment in Go

Source: https://docs.mender.io/api/2.7

Example using the net/http package to create a deployment.

```go
package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hosted.mender.io/api/management/v1/deployments/deployments", data)
    req.Header = headers

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

--------------------------------

### Redirect URI Configuration

Source: https://docs.mender.io/server-integration/oidc-federated-authentication

Example of deriving the required Redirect URI from the Mender start URL.

```bash
# If your login URL is
https://hosted.mender.io/api/management/v1/useradm/oidc/a82a2e98-833e-4a5a-9856-1e838702a35d/start
# you need to add
https://hosted.mender.io/api/management/v1/useradm/oidc/a82a2e98-833e-4a5a-9856-1e838702a35d/login
# to the Redirect URIs of your IdPs OpenID Connect Application
```

--------------------------------

### Create Trial Account in Go

Source: https://docs.mender.io/3.7/server-side-api

Implementation using the net/http package.

```go
package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/x-www-form-urlencoded"},
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hosted.mender.io/api/management/v2/tenantadm/tenants/trial", data)
    req.Header = headers

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

--------------------------------

### Initialize build environment

Source: https://docs.mender.io/1.0/artifacts/building-mender-yocto-image

Set up the build directory and change the current working directory to it.

```bash
source oe-init-build-envcopy
```

--------------------------------

### Get Saved Filter HTTP Responses

Source: https://docs.mender.io/2.4/apis/enterprise/management-apis/device-inventory-v2

Example JSON responses for retrieving a saved filter.

```json
{
  "id" : "myfilter",
  "name" : "My Filter",
  "terms" : [ {
    "scope" : "inventory",
    "attribute" : "serial_no",
    "type" : "$eq",
    "value" : "123456789"
  } ]
}
```

```json
{
  "error" : "filter not found",
  "request_id" : "f7881e82-0492-49fb-b459-795654e7188a"
}
```

```json
{
  "error" : "failed to decode device group data: JSON payload is empty",
  "request_id" : "f7881e82-0492-49fb-b459-795654e7188a"
}
```

--------------------------------

### Deploy Device Configuration via HTTP Requests

Source: https://docs.mender.io/3.6/server-side-api

Examples of how to trigger a device configuration deployment using standard HTTP tools and libraries.

```shell
# You can also use wget
curl -X POST https://hosted.mender.io/api/management/v1/deviceconfig/configurations/device/{deviceId}/deploy \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'
```

```http
POST https://hosted.mender.io/api/management/v1/deviceconfig/configurations/device/{deviceId}/deploy HTTP/1.1
Host: hosted.mender.io
Content-Type: application/json
Accept: application/json
```
Tokens:
Raw