Amazon EC2 Container Service

POST CreateCapacityProvider

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider

HEADERS

X-Amz-Target

BODY json

{
  "name": "",
  "autoScalingGroupProvider": "",
  "tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\",\n  \"tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:name ""
                                                                                                                                  :autoScalingGroupProvider ""
                                                                                                                                  :tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\",\n  \"tags\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\",\n  \"tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\",\n  \"tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\",\n  \"tags\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 64

{
  "name": "",
  "autoScalingGroupProvider": "",
  "tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\",\n  \"tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\",\n  \"tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\",\n  \"tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\",\n  \"tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  autoScalingGroupProvider: '',
  tags: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: '', autoScalingGroupProvider: '', tags: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","autoScalingGroupProvider":"","tags":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "autoScalingGroupProvider": "",\n  "tags": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\",\n  \"tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({name: '', autoScalingGroupProvider: '', tags: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {name: '', autoScalingGroupProvider: '', tags: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: '',
  autoScalingGroupProvider: '',
  tags: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: '', autoScalingGroupProvider: '', tags: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","autoScalingGroupProvider":"","tags":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"",
                              @"autoScalingGroupProvider": @"",
                              @"tags": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\",\n  \"tags\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'autoScalingGroupProvider' => '',
    'tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider', [
  'body' => '{
  "name": "",
  "autoScalingGroupProvider": "",
  "tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'autoScalingGroupProvider' => '',
  'tags' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => '',
  'autoScalingGroupProvider' => '',
  'tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "autoScalingGroupProvider": "",
  "tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "autoScalingGroupProvider": "",
  "tags": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\",\n  \"tags\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider"

payload = {
    "name": "",
    "autoScalingGroupProvider": "",
    "tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider"

payload <- "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\",\n  \"tags\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\",\n  \"tags\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\",\n  \"tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider";

    let payload = json!({
        "name": "",
        "autoScalingGroupProvider": "",
        "tags": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": "",
  "autoScalingGroupProvider": "",
  "tags": ""
}'

echo '{
  "name": "",
  "autoScalingGroupProvider": "",
  "tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "autoScalingGroupProvider": "",\n  "tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "name": "",
  "autoScalingGroupProvider": "",
  "tags": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCapacityProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateCluster

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster

HEADERS

X-Amz-Target

BODY json

{
  "clusterName": "",
  "tags": "",
  "settings": "",
  "configuration": "",
  "capacityProviders": "",
  "defaultCapacityProviderStrategy": "",
  "serviceConnectDefaults": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"clusterName\": \"\",\n  \"tags\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:clusterName ""
                                                                                                                         :tags ""
                                                                                                                         :settings ""
                                                                                                                         :configuration ""
                                                                                                                         :capacityProviders ""
                                                                                                                         :defaultCapacityProviderStrategy ""
                                                                                                                         :serviceConnectDefaults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"clusterName\": \"\",\n  \"tags\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"clusterName\": \"\",\n  \"tags\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"clusterName\": \"\",\n  \"tags\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster"

	payload := strings.NewReader("{\n  \"clusterName\": \"\",\n  \"tags\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 178

{
  "clusterName": "",
  "tags": "",
  "settings": "",
  "configuration": "",
  "capacityProviders": "",
  "defaultCapacityProviderStrategy": "",
  "serviceConnectDefaults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"clusterName\": \"\",\n  \"tags\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"clusterName\": \"\",\n  \"tags\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"clusterName\": \"\",\n  \"tags\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"clusterName\": \"\",\n  \"tags\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  clusterName: '',
  tags: '',
  settings: '',
  configuration: '',
  capacityProviders: '',
  defaultCapacityProviderStrategy: '',
  serviceConnectDefaults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    clusterName: '',
    tags: '',
    settings: '',
    configuration: '',
    capacityProviders: '',
    defaultCapacityProviderStrategy: '',
    serviceConnectDefaults: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"clusterName":"","tags":"","settings":"","configuration":"","capacityProviders":"","defaultCapacityProviderStrategy":"","serviceConnectDefaults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "clusterName": "",\n  "tags": "",\n  "settings": "",\n  "configuration": "",\n  "capacityProviders": "",\n  "defaultCapacityProviderStrategy": "",\n  "serviceConnectDefaults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"clusterName\": \"\",\n  \"tags\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  clusterName: '',
  tags: '',
  settings: '',
  configuration: '',
  capacityProviders: '',
  defaultCapacityProviderStrategy: '',
  serviceConnectDefaults: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    clusterName: '',
    tags: '',
    settings: '',
    configuration: '',
    capacityProviders: '',
    defaultCapacityProviderStrategy: '',
    serviceConnectDefaults: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  clusterName: '',
  tags: '',
  settings: '',
  configuration: '',
  capacityProviders: '',
  defaultCapacityProviderStrategy: '',
  serviceConnectDefaults: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    clusterName: '',
    tags: '',
    settings: '',
    configuration: '',
    capacityProviders: '',
    defaultCapacityProviderStrategy: '',
    serviceConnectDefaults: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"clusterName":"","tags":"","settings":"","configuration":"","capacityProviders":"","defaultCapacityProviderStrategy":"","serviceConnectDefaults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"clusterName": @"",
                              @"tags": @"",
                              @"settings": @"",
                              @"configuration": @"",
                              @"capacityProviders": @"",
                              @"defaultCapacityProviderStrategy": @"",
                              @"serviceConnectDefaults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"clusterName\": \"\",\n  \"tags\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'clusterName' => '',
    'tags' => '',
    'settings' => '',
    'configuration' => '',
    'capacityProviders' => '',
    'defaultCapacityProviderStrategy' => '',
    'serviceConnectDefaults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster', [
  'body' => '{
  "clusterName": "",
  "tags": "",
  "settings": "",
  "configuration": "",
  "capacityProviders": "",
  "defaultCapacityProviderStrategy": "",
  "serviceConnectDefaults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'clusterName' => '',
  'tags' => '',
  'settings' => '',
  'configuration' => '',
  'capacityProviders' => '',
  'defaultCapacityProviderStrategy' => '',
  'serviceConnectDefaults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'clusterName' => '',
  'tags' => '',
  'settings' => '',
  'configuration' => '',
  'capacityProviders' => '',
  'defaultCapacityProviderStrategy' => '',
  'serviceConnectDefaults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clusterName": "",
  "tags": "",
  "settings": "",
  "configuration": "",
  "capacityProviders": "",
  "defaultCapacityProviderStrategy": "",
  "serviceConnectDefaults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clusterName": "",
  "tags": "",
  "settings": "",
  "configuration": "",
  "capacityProviders": "",
  "defaultCapacityProviderStrategy": "",
  "serviceConnectDefaults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"clusterName\": \"\",\n  \"tags\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster"

payload = {
    "clusterName": "",
    "tags": "",
    "settings": "",
    "configuration": "",
    "capacityProviders": "",
    "defaultCapacityProviderStrategy": "",
    "serviceConnectDefaults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster"

payload <- "{\n  \"clusterName\": \"\",\n  \"tags\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"clusterName\": \"\",\n  \"tags\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"clusterName\": \"\",\n  \"tags\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster";

    let payload = json!({
        "clusterName": "",
        "tags": "",
        "settings": "",
        "configuration": "",
        "capacityProviders": "",
        "defaultCapacityProviderStrategy": "",
        "serviceConnectDefaults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "clusterName": "",
  "tags": "",
  "settings": "",
  "configuration": "",
  "capacityProviders": "",
  "defaultCapacityProviderStrategy": "",
  "serviceConnectDefaults": ""
}'

echo '{
  "clusterName": "",
  "tags": "",
  "settings": "",
  "configuration": "",
  "capacityProviders": "",
  "defaultCapacityProviderStrategy": "",
  "serviceConnectDefaults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "clusterName": "",\n  "tags": "",\n  "settings": "",\n  "configuration": "",\n  "capacityProviders": "",\n  "defaultCapacityProviderStrategy": "",\n  "serviceConnectDefaults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "clusterName": "",
  "tags": "",
  "settings": "",
  "configuration": "",
  "capacityProviders": "",
  "defaultCapacityProviderStrategy": "",
  "serviceConnectDefaults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateCluster")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "cluster": {
    "activeServicesCount": 0,
    "clusterArn": "arn:aws:ecs:us-east-1:012345678910:cluster/my_cluster",
    "clusterName": "my_cluster",
    "pendingTasksCount": 0,
    "registeredContainerInstancesCount": 0,
    "runningTasksCount": 0,
    "status": "ACTIVE"
  }
}

POST CreateService

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "serviceName": "",
  "taskDefinition": "",
  "loadBalancers": "",
  "serviceRegistries": "",
  "desiredCount": "",
  "clientToken": "",
  "launchType": "",
  "capacityProviderStrategy": "",
  "platformVersion": "",
  "role": "",
  "deploymentConfiguration": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "networkConfiguration": "",
  "healthCheckGracePeriodSeconds": "",
  "schedulingStrategy": "",
  "deploymentController": "",
  "tags": "",
  "enableECSManagedTags": "",
  "propagateTags": "",
  "enableExecuteCommand": "",
  "serviceConnectConfiguration": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"serviceName\": \"\",\n  \"taskDefinition\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"desiredCount\": \"\",\n  \"clientToken\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"role\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"networkConfiguration\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"schedulingStrategy\": \"\",\n  \"deploymentController\": \"\",\n  \"tags\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"propagateTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:cluster ""
                                                                                                                         :serviceName ""
                                                                                                                         :taskDefinition ""
                                                                                                                         :loadBalancers ""
                                                                                                                         :serviceRegistries ""
                                                                                                                         :desiredCount ""
                                                                                                                         :clientToken ""
                                                                                                                         :launchType ""
                                                                                                                         :capacityProviderStrategy ""
                                                                                                                         :platformVersion ""
                                                                                                                         :role ""
                                                                                                                         :deploymentConfiguration ""
                                                                                                                         :placementConstraints ""
                                                                                                                         :placementStrategy ""
                                                                                                                         :networkConfiguration ""
                                                                                                                         :healthCheckGracePeriodSeconds ""
                                                                                                                         :schedulingStrategy ""
                                                                                                                         :deploymentController ""
                                                                                                                         :tags ""
                                                                                                                         :enableECSManagedTags ""
                                                                                                                         :propagateTags ""
                                                                                                                         :enableExecuteCommand ""
                                                                                                                         :serviceConnectConfiguration ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"serviceName\": \"\",\n  \"taskDefinition\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"desiredCount\": \"\",\n  \"clientToken\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"role\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"networkConfiguration\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"schedulingStrategy\": \"\",\n  \"deploymentController\": \"\",\n  \"tags\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"propagateTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"serviceName\": \"\",\n  \"taskDefinition\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"desiredCount\": \"\",\n  \"clientToken\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"role\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"networkConfiguration\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"schedulingStrategy\": \"\",\n  \"deploymentController\": \"\",\n  \"tags\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"propagateTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"serviceName\": \"\",\n  \"taskDefinition\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"desiredCount\": \"\",\n  \"clientToken\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"role\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"networkConfiguration\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"schedulingStrategy\": \"\",\n  \"deploymentController\": \"\",\n  \"tags\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"propagateTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"serviceName\": \"\",\n  \"taskDefinition\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"desiredCount\": \"\",\n  \"clientToken\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"role\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"networkConfiguration\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"schedulingStrategy\": \"\",\n  \"deploymentController\": \"\",\n  \"tags\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"propagateTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 601

{
  "cluster": "",
  "serviceName": "",
  "taskDefinition": "",
  "loadBalancers": "",
  "serviceRegistries": "",
  "desiredCount": "",
  "clientToken": "",
  "launchType": "",
  "capacityProviderStrategy": "",
  "platformVersion": "",
  "role": "",
  "deploymentConfiguration": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "networkConfiguration": "",
  "healthCheckGracePeriodSeconds": "",
  "schedulingStrategy": "",
  "deploymentController": "",
  "tags": "",
  "enableECSManagedTags": "",
  "propagateTags": "",
  "enableExecuteCommand": "",
  "serviceConnectConfiguration": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"serviceName\": \"\",\n  \"taskDefinition\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"desiredCount\": \"\",\n  \"clientToken\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"role\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"networkConfiguration\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"schedulingStrategy\": \"\",\n  \"deploymentController\": \"\",\n  \"tags\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"propagateTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"serviceName\": \"\",\n  \"taskDefinition\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"desiredCount\": \"\",\n  \"clientToken\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"role\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"networkConfiguration\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"schedulingStrategy\": \"\",\n  \"deploymentController\": \"\",\n  \"tags\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"propagateTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"serviceName\": \"\",\n  \"taskDefinition\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"desiredCount\": \"\",\n  \"clientToken\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"role\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"networkConfiguration\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"schedulingStrategy\": \"\",\n  \"deploymentController\": \"\",\n  \"tags\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"propagateTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"serviceName\": \"\",\n  \"taskDefinition\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"desiredCount\": \"\",\n  \"clientToken\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"role\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"networkConfiguration\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"schedulingStrategy\": \"\",\n  \"deploymentController\": \"\",\n  \"tags\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"propagateTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  serviceName: '',
  taskDefinition: '',
  loadBalancers: '',
  serviceRegistries: '',
  desiredCount: '',
  clientToken: '',
  launchType: '',
  capacityProviderStrategy: '',
  platformVersion: '',
  role: '',
  deploymentConfiguration: '',
  placementConstraints: '',
  placementStrategy: '',
  networkConfiguration: '',
  healthCheckGracePeriodSeconds: '',
  schedulingStrategy: '',
  deploymentController: '',
  tags: '',
  enableECSManagedTags: '',
  propagateTags: '',
  enableExecuteCommand: '',
  serviceConnectConfiguration: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    cluster: '',
    serviceName: '',
    taskDefinition: '',
    loadBalancers: '',
    serviceRegistries: '',
    desiredCount: '',
    clientToken: '',
    launchType: '',
    capacityProviderStrategy: '',
    platformVersion: '',
    role: '',
    deploymentConfiguration: '',
    placementConstraints: '',
    placementStrategy: '',
    networkConfiguration: '',
    healthCheckGracePeriodSeconds: '',
    schedulingStrategy: '',
    deploymentController: '',
    tags: '',
    enableECSManagedTags: '',
    propagateTags: '',
    enableExecuteCommand: '',
    serviceConnectConfiguration: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","serviceName":"","taskDefinition":"","loadBalancers":"","serviceRegistries":"","desiredCount":"","clientToken":"","launchType":"","capacityProviderStrategy":"","platformVersion":"","role":"","deploymentConfiguration":"","placementConstraints":"","placementStrategy":"","networkConfiguration":"","healthCheckGracePeriodSeconds":"","schedulingStrategy":"","deploymentController":"","tags":"","enableECSManagedTags":"","propagateTags":"","enableExecuteCommand":"","serviceConnectConfiguration":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "serviceName": "",\n  "taskDefinition": "",\n  "loadBalancers": "",\n  "serviceRegistries": "",\n  "desiredCount": "",\n  "clientToken": "",\n  "launchType": "",\n  "capacityProviderStrategy": "",\n  "platformVersion": "",\n  "role": "",\n  "deploymentConfiguration": "",\n  "placementConstraints": "",\n  "placementStrategy": "",\n  "networkConfiguration": "",\n  "healthCheckGracePeriodSeconds": "",\n  "schedulingStrategy": "",\n  "deploymentController": "",\n  "tags": "",\n  "enableECSManagedTags": "",\n  "propagateTags": "",\n  "enableExecuteCommand": "",\n  "serviceConnectConfiguration": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"serviceName\": \"\",\n  \"taskDefinition\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"desiredCount\": \"\",\n  \"clientToken\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"role\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"networkConfiguration\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"schedulingStrategy\": \"\",\n  \"deploymentController\": \"\",\n  \"tags\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"propagateTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  cluster: '',
  serviceName: '',
  taskDefinition: '',
  loadBalancers: '',
  serviceRegistries: '',
  desiredCount: '',
  clientToken: '',
  launchType: '',
  capacityProviderStrategy: '',
  platformVersion: '',
  role: '',
  deploymentConfiguration: '',
  placementConstraints: '',
  placementStrategy: '',
  networkConfiguration: '',
  healthCheckGracePeriodSeconds: '',
  schedulingStrategy: '',
  deploymentController: '',
  tags: '',
  enableECSManagedTags: '',
  propagateTags: '',
  enableExecuteCommand: '',
  serviceConnectConfiguration: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    cluster: '',
    serviceName: '',
    taskDefinition: '',
    loadBalancers: '',
    serviceRegistries: '',
    desiredCount: '',
    clientToken: '',
    launchType: '',
    capacityProviderStrategy: '',
    platformVersion: '',
    role: '',
    deploymentConfiguration: '',
    placementConstraints: '',
    placementStrategy: '',
    networkConfiguration: '',
    healthCheckGracePeriodSeconds: '',
    schedulingStrategy: '',
    deploymentController: '',
    tags: '',
    enableECSManagedTags: '',
    propagateTags: '',
    enableExecuteCommand: '',
    serviceConnectConfiguration: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  serviceName: '',
  taskDefinition: '',
  loadBalancers: '',
  serviceRegistries: '',
  desiredCount: '',
  clientToken: '',
  launchType: '',
  capacityProviderStrategy: '',
  platformVersion: '',
  role: '',
  deploymentConfiguration: '',
  placementConstraints: '',
  placementStrategy: '',
  networkConfiguration: '',
  healthCheckGracePeriodSeconds: '',
  schedulingStrategy: '',
  deploymentController: '',
  tags: '',
  enableECSManagedTags: '',
  propagateTags: '',
  enableExecuteCommand: '',
  serviceConnectConfiguration: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    cluster: '',
    serviceName: '',
    taskDefinition: '',
    loadBalancers: '',
    serviceRegistries: '',
    desiredCount: '',
    clientToken: '',
    launchType: '',
    capacityProviderStrategy: '',
    platformVersion: '',
    role: '',
    deploymentConfiguration: '',
    placementConstraints: '',
    placementStrategy: '',
    networkConfiguration: '',
    healthCheckGracePeriodSeconds: '',
    schedulingStrategy: '',
    deploymentController: '',
    tags: '',
    enableECSManagedTags: '',
    propagateTags: '',
    enableExecuteCommand: '',
    serviceConnectConfiguration: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","serviceName":"","taskDefinition":"","loadBalancers":"","serviceRegistries":"","desiredCount":"","clientToken":"","launchType":"","capacityProviderStrategy":"","platformVersion":"","role":"","deploymentConfiguration":"","placementConstraints":"","placementStrategy":"","networkConfiguration":"","healthCheckGracePeriodSeconds":"","schedulingStrategy":"","deploymentController":"","tags":"","enableECSManagedTags":"","propagateTags":"","enableExecuteCommand":"","serviceConnectConfiguration":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"serviceName": @"",
                              @"taskDefinition": @"",
                              @"loadBalancers": @"",
                              @"serviceRegistries": @"",
                              @"desiredCount": @"",
                              @"clientToken": @"",
                              @"launchType": @"",
                              @"capacityProviderStrategy": @"",
                              @"platformVersion": @"",
                              @"role": @"",
                              @"deploymentConfiguration": @"",
                              @"placementConstraints": @"",
                              @"placementStrategy": @"",
                              @"networkConfiguration": @"",
                              @"healthCheckGracePeriodSeconds": @"",
                              @"schedulingStrategy": @"",
                              @"deploymentController": @"",
                              @"tags": @"",
                              @"enableECSManagedTags": @"",
                              @"propagateTags": @"",
                              @"enableExecuteCommand": @"",
                              @"serviceConnectConfiguration": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"serviceName\": \"\",\n  \"taskDefinition\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"desiredCount\": \"\",\n  \"clientToken\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"role\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"networkConfiguration\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"schedulingStrategy\": \"\",\n  \"deploymentController\": \"\",\n  \"tags\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"propagateTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'serviceName' => '',
    'taskDefinition' => '',
    'loadBalancers' => '',
    'serviceRegistries' => '',
    'desiredCount' => '',
    'clientToken' => '',
    'launchType' => '',
    'capacityProviderStrategy' => '',
    'platformVersion' => '',
    'role' => '',
    'deploymentConfiguration' => '',
    'placementConstraints' => '',
    'placementStrategy' => '',
    'networkConfiguration' => '',
    'healthCheckGracePeriodSeconds' => '',
    'schedulingStrategy' => '',
    'deploymentController' => '',
    'tags' => '',
    'enableECSManagedTags' => '',
    'propagateTags' => '',
    'enableExecuteCommand' => '',
    'serviceConnectConfiguration' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService', [
  'body' => '{
  "cluster": "",
  "serviceName": "",
  "taskDefinition": "",
  "loadBalancers": "",
  "serviceRegistries": "",
  "desiredCount": "",
  "clientToken": "",
  "launchType": "",
  "capacityProviderStrategy": "",
  "platformVersion": "",
  "role": "",
  "deploymentConfiguration": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "networkConfiguration": "",
  "healthCheckGracePeriodSeconds": "",
  "schedulingStrategy": "",
  "deploymentController": "",
  "tags": "",
  "enableECSManagedTags": "",
  "propagateTags": "",
  "enableExecuteCommand": "",
  "serviceConnectConfiguration": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'serviceName' => '',
  'taskDefinition' => '',
  'loadBalancers' => '',
  'serviceRegistries' => '',
  'desiredCount' => '',
  'clientToken' => '',
  'launchType' => '',
  'capacityProviderStrategy' => '',
  'platformVersion' => '',
  'role' => '',
  'deploymentConfiguration' => '',
  'placementConstraints' => '',
  'placementStrategy' => '',
  'networkConfiguration' => '',
  'healthCheckGracePeriodSeconds' => '',
  'schedulingStrategy' => '',
  'deploymentController' => '',
  'tags' => '',
  'enableECSManagedTags' => '',
  'propagateTags' => '',
  'enableExecuteCommand' => '',
  'serviceConnectConfiguration' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'serviceName' => '',
  'taskDefinition' => '',
  'loadBalancers' => '',
  'serviceRegistries' => '',
  'desiredCount' => '',
  'clientToken' => '',
  'launchType' => '',
  'capacityProviderStrategy' => '',
  'platformVersion' => '',
  'role' => '',
  'deploymentConfiguration' => '',
  'placementConstraints' => '',
  'placementStrategy' => '',
  'networkConfiguration' => '',
  'healthCheckGracePeriodSeconds' => '',
  'schedulingStrategy' => '',
  'deploymentController' => '',
  'tags' => '',
  'enableECSManagedTags' => '',
  'propagateTags' => '',
  'enableExecuteCommand' => '',
  'serviceConnectConfiguration' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "serviceName": "",
  "taskDefinition": "",
  "loadBalancers": "",
  "serviceRegistries": "",
  "desiredCount": "",
  "clientToken": "",
  "launchType": "",
  "capacityProviderStrategy": "",
  "platformVersion": "",
  "role": "",
  "deploymentConfiguration": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "networkConfiguration": "",
  "healthCheckGracePeriodSeconds": "",
  "schedulingStrategy": "",
  "deploymentController": "",
  "tags": "",
  "enableECSManagedTags": "",
  "propagateTags": "",
  "enableExecuteCommand": "",
  "serviceConnectConfiguration": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "serviceName": "",
  "taskDefinition": "",
  "loadBalancers": "",
  "serviceRegistries": "",
  "desiredCount": "",
  "clientToken": "",
  "launchType": "",
  "capacityProviderStrategy": "",
  "platformVersion": "",
  "role": "",
  "deploymentConfiguration": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "networkConfiguration": "",
  "healthCheckGracePeriodSeconds": "",
  "schedulingStrategy": "",
  "deploymentController": "",
  "tags": "",
  "enableECSManagedTags": "",
  "propagateTags": "",
  "enableExecuteCommand": "",
  "serviceConnectConfiguration": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"serviceName\": \"\",\n  \"taskDefinition\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"desiredCount\": \"\",\n  \"clientToken\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"role\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"networkConfiguration\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"schedulingStrategy\": \"\",\n  \"deploymentController\": \"\",\n  \"tags\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"propagateTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService"

payload = {
    "cluster": "",
    "serviceName": "",
    "taskDefinition": "",
    "loadBalancers": "",
    "serviceRegistries": "",
    "desiredCount": "",
    "clientToken": "",
    "launchType": "",
    "capacityProviderStrategy": "",
    "platformVersion": "",
    "role": "",
    "deploymentConfiguration": "",
    "placementConstraints": "",
    "placementStrategy": "",
    "networkConfiguration": "",
    "healthCheckGracePeriodSeconds": "",
    "schedulingStrategy": "",
    "deploymentController": "",
    "tags": "",
    "enableECSManagedTags": "",
    "propagateTags": "",
    "enableExecuteCommand": "",
    "serviceConnectConfiguration": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService"

payload <- "{\n  \"cluster\": \"\",\n  \"serviceName\": \"\",\n  \"taskDefinition\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"desiredCount\": \"\",\n  \"clientToken\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"role\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"networkConfiguration\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"schedulingStrategy\": \"\",\n  \"deploymentController\": \"\",\n  \"tags\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"propagateTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"serviceName\": \"\",\n  \"taskDefinition\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"desiredCount\": \"\",\n  \"clientToken\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"role\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"networkConfiguration\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"schedulingStrategy\": \"\",\n  \"deploymentController\": \"\",\n  \"tags\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"propagateTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"serviceName\": \"\",\n  \"taskDefinition\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"desiredCount\": \"\",\n  \"clientToken\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"role\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"networkConfiguration\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"schedulingStrategy\": \"\",\n  \"deploymentController\": \"\",\n  \"tags\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"propagateTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService";

    let payload = json!({
        "cluster": "",
        "serviceName": "",
        "taskDefinition": "",
        "loadBalancers": "",
        "serviceRegistries": "",
        "desiredCount": "",
        "clientToken": "",
        "launchType": "",
        "capacityProviderStrategy": "",
        "platformVersion": "",
        "role": "",
        "deploymentConfiguration": "",
        "placementConstraints": "",
        "placementStrategy": "",
        "networkConfiguration": "",
        "healthCheckGracePeriodSeconds": "",
        "schedulingStrategy": "",
        "deploymentController": "",
        "tags": "",
        "enableECSManagedTags": "",
        "propagateTags": "",
        "enableExecuteCommand": "",
        "serviceConnectConfiguration": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "serviceName": "",
  "taskDefinition": "",
  "loadBalancers": "",
  "serviceRegistries": "",
  "desiredCount": "",
  "clientToken": "",
  "launchType": "",
  "capacityProviderStrategy": "",
  "platformVersion": "",
  "role": "",
  "deploymentConfiguration": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "networkConfiguration": "",
  "healthCheckGracePeriodSeconds": "",
  "schedulingStrategy": "",
  "deploymentController": "",
  "tags": "",
  "enableECSManagedTags": "",
  "propagateTags": "",
  "enableExecuteCommand": "",
  "serviceConnectConfiguration": ""
}'

echo '{
  "cluster": "",
  "serviceName": "",
  "taskDefinition": "",
  "loadBalancers": "",
  "serviceRegistries": "",
  "desiredCount": "",
  "clientToken": "",
  "launchType": "",
  "capacityProviderStrategy": "",
  "platformVersion": "",
  "role": "",
  "deploymentConfiguration": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "networkConfiguration": "",
  "healthCheckGracePeriodSeconds": "",
  "schedulingStrategy": "",
  "deploymentController": "",
  "tags": "",
  "enableECSManagedTags": "",
  "propagateTags": "",
  "enableExecuteCommand": "",
  "serviceConnectConfiguration": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "serviceName": "",\n  "taskDefinition": "",\n  "loadBalancers": "",\n  "serviceRegistries": "",\n  "desiredCount": "",\n  "clientToken": "",\n  "launchType": "",\n  "capacityProviderStrategy": "",\n  "platformVersion": "",\n  "role": "",\n  "deploymentConfiguration": "",\n  "placementConstraints": "",\n  "placementStrategy": "",\n  "networkConfiguration": "",\n  "healthCheckGracePeriodSeconds": "",\n  "schedulingStrategy": "",\n  "deploymentController": "",\n  "tags": "",\n  "enableECSManagedTags": "",\n  "propagateTags": "",\n  "enableExecuteCommand": "",\n  "serviceConnectConfiguration": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "serviceName": "",
  "taskDefinition": "",
  "loadBalancers": "",
  "serviceRegistries": "",
  "desiredCount": "",
  "clientToken": "",
  "launchType": "",
  "capacityProviderStrategy": "",
  "platformVersion": "",
  "role": "",
  "deploymentConfiguration": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "networkConfiguration": "",
  "healthCheckGracePeriodSeconds": "",
  "schedulingStrategy": "",
  "deploymentController": "",
  "tags": "",
  "enableECSManagedTags": "",
  "propagateTags": "",
  "enableExecuteCommand": "",
  "serviceConnectConfiguration": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateService")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "service": {
    "clusterArn": "arn:aws:ecs:us-east-1:012345678910:cluster/default",
    "createdAt": "2016-08-29T16:02:54.884Z",
    "deploymentConfiguration": {
      "maximumPercent": 200,
      "minimumHealthyPercent": 100
    },
    "deployments": [
      {
        "createdAt": "2016-08-29T16:02:54.884Z",
        "desiredCount": 10,
        "id": "ecs-svc/9223370564343000923",
        "pendingCount": 0,
        "runningCount": 0,
        "status": "PRIMARY",
        "taskDefinition": "arn:aws:ecs:us-east-1:012345678910:task-definition/console-sample-app-static:6",
        "updatedAt": "2016-08-29T16:02:54.884Z"
      }
    ],
    "desiredCount": 10,
    "events": [],
    "loadBalancers": [
      {
        "containerName": "simple-app",
        "containerPort": 80,
        "loadBalancerName": "EC2Contai-EcsElast-15DCDAURT3ZO2"
      }
    ],
    "pendingCount": 0,
    "roleArn": "arn:aws:iam::012345678910:role/ecsServiceRole",
    "runningCount": 0,
    "serviceArn": "arn:aws:ecs:us-east-1:012345678910:service/ecs-simple-service-elb",
    "serviceName": "ecs-simple-service-elb",
    "status": "ACTIVE",
    "taskDefinition": "arn:aws:ecs:us-east-1:012345678910:task-definition/console-sample-app-static:6"
  }
}

POST CreateTaskSet

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet

HEADERS

X-Amz-Target

BODY json

{
  "service": "",
  "cluster": "",
  "externalId": "",
  "taskDefinition": "",
  "networkConfiguration": "",
  "loadBalancers": "",
  "serviceRegistries": "",
  "launchType": "",
  "capacityProviderStrategy": "",
  "platformVersion": "",
  "scale": "",
  "clientToken": "",
  "tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"service\": \"\",\n  \"cluster\": \"\",\n  \"externalId\": \"\",\n  \"taskDefinition\": \"\",\n  \"networkConfiguration\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"scale\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:service ""
                                                                                                                         :cluster ""
                                                                                                                         :externalId ""
                                                                                                                         :taskDefinition ""
                                                                                                                         :networkConfiguration ""
                                                                                                                         :loadBalancers ""
                                                                                                                         :serviceRegistries ""
                                                                                                                         :launchType ""
                                                                                                                         :capacityProviderStrategy ""
                                                                                                                         :platformVersion ""
                                                                                                                         :scale ""
                                                                                                                         :clientToken ""
                                                                                                                         :tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"service\": \"\",\n  \"cluster\": \"\",\n  \"externalId\": \"\",\n  \"taskDefinition\": \"\",\n  \"networkConfiguration\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"scale\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"service\": \"\",\n  \"cluster\": \"\",\n  \"externalId\": \"\",\n  \"taskDefinition\": \"\",\n  \"networkConfiguration\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"scale\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"service\": \"\",\n  \"cluster\": \"\",\n  \"externalId\": \"\",\n  \"taskDefinition\": \"\",\n  \"networkConfiguration\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"scale\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet"

	payload := strings.NewReader("{\n  \"service\": \"\",\n  \"cluster\": \"\",\n  \"externalId\": \"\",\n  \"taskDefinition\": \"\",\n  \"networkConfiguration\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"scale\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 289

{
  "service": "",
  "cluster": "",
  "externalId": "",
  "taskDefinition": "",
  "networkConfiguration": "",
  "loadBalancers": "",
  "serviceRegistries": "",
  "launchType": "",
  "capacityProviderStrategy": "",
  "platformVersion": "",
  "scale": "",
  "clientToken": "",
  "tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"service\": \"\",\n  \"cluster\": \"\",\n  \"externalId\": \"\",\n  \"taskDefinition\": \"\",\n  \"networkConfiguration\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"scale\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"service\": \"\",\n  \"cluster\": \"\",\n  \"externalId\": \"\",\n  \"taskDefinition\": \"\",\n  \"networkConfiguration\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"scale\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"service\": \"\",\n  \"cluster\": \"\",\n  \"externalId\": \"\",\n  \"taskDefinition\": \"\",\n  \"networkConfiguration\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"scale\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"service\": \"\",\n  \"cluster\": \"\",\n  \"externalId\": \"\",\n  \"taskDefinition\": \"\",\n  \"networkConfiguration\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"scale\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  service: '',
  cluster: '',
  externalId: '',
  taskDefinition: '',
  networkConfiguration: '',
  loadBalancers: '',
  serviceRegistries: '',
  launchType: '',
  capacityProviderStrategy: '',
  platformVersion: '',
  scale: '',
  clientToken: '',
  tags: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    service: '',
    cluster: '',
    externalId: '',
    taskDefinition: '',
    networkConfiguration: '',
    loadBalancers: '',
    serviceRegistries: '',
    launchType: '',
    capacityProviderStrategy: '',
    platformVersion: '',
    scale: '',
    clientToken: '',
    tags: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"service":"","cluster":"","externalId":"","taskDefinition":"","networkConfiguration":"","loadBalancers":"","serviceRegistries":"","launchType":"","capacityProviderStrategy":"","platformVersion":"","scale":"","clientToken":"","tags":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "service": "",\n  "cluster": "",\n  "externalId": "",\n  "taskDefinition": "",\n  "networkConfiguration": "",\n  "loadBalancers": "",\n  "serviceRegistries": "",\n  "launchType": "",\n  "capacityProviderStrategy": "",\n  "platformVersion": "",\n  "scale": "",\n  "clientToken": "",\n  "tags": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"service\": \"\",\n  \"cluster\": \"\",\n  \"externalId\": \"\",\n  \"taskDefinition\": \"\",\n  \"networkConfiguration\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"scale\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  service: '',
  cluster: '',
  externalId: '',
  taskDefinition: '',
  networkConfiguration: '',
  loadBalancers: '',
  serviceRegistries: '',
  launchType: '',
  capacityProviderStrategy: '',
  platformVersion: '',
  scale: '',
  clientToken: '',
  tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    service: '',
    cluster: '',
    externalId: '',
    taskDefinition: '',
    networkConfiguration: '',
    loadBalancers: '',
    serviceRegistries: '',
    launchType: '',
    capacityProviderStrategy: '',
    platformVersion: '',
    scale: '',
    clientToken: '',
    tags: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  service: '',
  cluster: '',
  externalId: '',
  taskDefinition: '',
  networkConfiguration: '',
  loadBalancers: '',
  serviceRegistries: '',
  launchType: '',
  capacityProviderStrategy: '',
  platformVersion: '',
  scale: '',
  clientToken: '',
  tags: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    service: '',
    cluster: '',
    externalId: '',
    taskDefinition: '',
    networkConfiguration: '',
    loadBalancers: '',
    serviceRegistries: '',
    launchType: '',
    capacityProviderStrategy: '',
    platformVersion: '',
    scale: '',
    clientToken: '',
    tags: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"service":"","cluster":"","externalId":"","taskDefinition":"","networkConfiguration":"","loadBalancers":"","serviceRegistries":"","launchType":"","capacityProviderStrategy":"","platformVersion":"","scale":"","clientToken":"","tags":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"service": @"",
                              @"cluster": @"",
                              @"externalId": @"",
                              @"taskDefinition": @"",
                              @"networkConfiguration": @"",
                              @"loadBalancers": @"",
                              @"serviceRegistries": @"",
                              @"launchType": @"",
                              @"capacityProviderStrategy": @"",
                              @"platformVersion": @"",
                              @"scale": @"",
                              @"clientToken": @"",
                              @"tags": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"service\": \"\",\n  \"cluster\": \"\",\n  \"externalId\": \"\",\n  \"taskDefinition\": \"\",\n  \"networkConfiguration\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"scale\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'service' => '',
    'cluster' => '',
    'externalId' => '',
    'taskDefinition' => '',
    'networkConfiguration' => '',
    'loadBalancers' => '',
    'serviceRegistries' => '',
    'launchType' => '',
    'capacityProviderStrategy' => '',
    'platformVersion' => '',
    'scale' => '',
    'clientToken' => '',
    'tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet', [
  'body' => '{
  "service": "",
  "cluster": "",
  "externalId": "",
  "taskDefinition": "",
  "networkConfiguration": "",
  "loadBalancers": "",
  "serviceRegistries": "",
  "launchType": "",
  "capacityProviderStrategy": "",
  "platformVersion": "",
  "scale": "",
  "clientToken": "",
  "tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'service' => '',
  'cluster' => '',
  'externalId' => '',
  'taskDefinition' => '',
  'networkConfiguration' => '',
  'loadBalancers' => '',
  'serviceRegistries' => '',
  'launchType' => '',
  'capacityProviderStrategy' => '',
  'platformVersion' => '',
  'scale' => '',
  'clientToken' => '',
  'tags' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'service' => '',
  'cluster' => '',
  'externalId' => '',
  'taskDefinition' => '',
  'networkConfiguration' => '',
  'loadBalancers' => '',
  'serviceRegistries' => '',
  'launchType' => '',
  'capacityProviderStrategy' => '',
  'platformVersion' => '',
  'scale' => '',
  'clientToken' => '',
  'tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "service": "",
  "cluster": "",
  "externalId": "",
  "taskDefinition": "",
  "networkConfiguration": "",
  "loadBalancers": "",
  "serviceRegistries": "",
  "launchType": "",
  "capacityProviderStrategy": "",
  "platformVersion": "",
  "scale": "",
  "clientToken": "",
  "tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "service": "",
  "cluster": "",
  "externalId": "",
  "taskDefinition": "",
  "networkConfiguration": "",
  "loadBalancers": "",
  "serviceRegistries": "",
  "launchType": "",
  "capacityProviderStrategy": "",
  "platformVersion": "",
  "scale": "",
  "clientToken": "",
  "tags": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"service\": \"\",\n  \"cluster\": \"\",\n  \"externalId\": \"\",\n  \"taskDefinition\": \"\",\n  \"networkConfiguration\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"scale\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet"

payload = {
    "service": "",
    "cluster": "",
    "externalId": "",
    "taskDefinition": "",
    "networkConfiguration": "",
    "loadBalancers": "",
    "serviceRegistries": "",
    "launchType": "",
    "capacityProviderStrategy": "",
    "platformVersion": "",
    "scale": "",
    "clientToken": "",
    "tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet"

payload <- "{\n  \"service\": \"\",\n  \"cluster\": \"\",\n  \"externalId\": \"\",\n  \"taskDefinition\": \"\",\n  \"networkConfiguration\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"scale\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"service\": \"\",\n  \"cluster\": \"\",\n  \"externalId\": \"\",\n  \"taskDefinition\": \"\",\n  \"networkConfiguration\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"scale\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"service\": \"\",\n  \"cluster\": \"\",\n  \"externalId\": \"\",\n  \"taskDefinition\": \"\",\n  \"networkConfiguration\": \"\",\n  \"loadBalancers\": \"\",\n  \"serviceRegistries\": \"\",\n  \"launchType\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"scale\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet";

    let payload = json!({
        "service": "",
        "cluster": "",
        "externalId": "",
        "taskDefinition": "",
        "networkConfiguration": "",
        "loadBalancers": "",
        "serviceRegistries": "",
        "launchType": "",
        "capacityProviderStrategy": "",
        "platformVersion": "",
        "scale": "",
        "clientToken": "",
        "tags": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "service": "",
  "cluster": "",
  "externalId": "",
  "taskDefinition": "",
  "networkConfiguration": "",
  "loadBalancers": "",
  "serviceRegistries": "",
  "launchType": "",
  "capacityProviderStrategy": "",
  "platformVersion": "",
  "scale": "",
  "clientToken": "",
  "tags": ""
}'

echo '{
  "service": "",
  "cluster": "",
  "externalId": "",
  "taskDefinition": "",
  "networkConfiguration": "",
  "loadBalancers": "",
  "serviceRegistries": "",
  "launchType": "",
  "capacityProviderStrategy": "",
  "platformVersion": "",
  "scale": "",
  "clientToken": "",
  "tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "service": "",\n  "cluster": "",\n  "externalId": "",\n  "taskDefinition": "",\n  "networkConfiguration": "",\n  "loadBalancers": "",\n  "serviceRegistries": "",\n  "launchType": "",\n  "capacityProviderStrategy": "",\n  "platformVersion": "",\n  "scale": "",\n  "clientToken": "",\n  "tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "service": "",
  "cluster": "",
  "externalId": "",
  "taskDefinition": "",
  "networkConfiguration": "",
  "loadBalancers": "",
  "serviceRegistries": "",
  "launchType": "",
  "capacityProviderStrategy": "",
  "platformVersion": "",
  "scale": "",
  "clientToken": "",
  "tags": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.CreateTaskSet")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteAccountSetting

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting

HEADERS

X-Amz-Target

BODY json

{
  "name": "",
  "principalArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\",\n  \"principalArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting" {:headers {:x-amz-target ""}
                                                                                                                  :content-type :json
                                                                                                                  :form-params {:name ""
                                                                                                                                :principalArn ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"principalArn\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"name\": \"\",\n  \"principalArn\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"principalArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"principalArn\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 38

{
  "name": "",
  "principalArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"principalArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"principalArn\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"principalArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"principalArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  principalArn: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: '', principalArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","principalArn":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "principalArn": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"principalArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({name: '', principalArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {name: '', principalArn: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: '',
  principalArn: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: '', principalArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","principalArn":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"",
                              @"principalArn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"principalArn\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'principalArn' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting', [
  'body' => '{
  "name": "",
  "principalArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'principalArn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => '',
  'principalArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "principalArn": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "principalArn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\",\n  \"principalArn\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting"

payload = {
    "name": "",
    "principalArn": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting"

payload <- "{\n  \"name\": \"\",\n  \"principalArn\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"principalArn\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"name\": \"\",\n  \"principalArn\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting";

    let payload = json!({
        "name": "",
        "principalArn": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": "",
  "principalArn": ""
}'

echo '{
  "name": "",
  "principalArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "principalArn": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "name": "",
  "principalArn": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAccountSetting")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "setting": {
    "name": "containerInstanceLongArnFormat",
    "value": "enabled",
    "principalArn": "arn:aws:iam:::user/principalName"
  }
}

POST DeleteAttributes

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "attributes": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:cluster ""
                                                                                                                            :attributes ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 39

{
  "cluster": "",
  "attributes": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  attributes: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', attributes: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","attributes":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "attributes": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', attributes: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', attributes: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  attributes: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', attributes: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","attributes":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"attributes": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'attributes' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes', [
  'body' => '{
  "cluster": "",
  "attributes": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'attributes' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'attributes' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "attributes": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "attributes": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes"

payload = {
    "cluster": "",
    "attributes": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes"

payload <- "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes";

    let payload = json!({
        "cluster": "",
        "attributes": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "attributes": ""
}'

echo '{
  "cluster": "",
  "attributes": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "attributes": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "attributes": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteAttributes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteCapacityProvider

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider

HEADERS

X-Amz-Target

BODY json

{
  "capacityProvider": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"capacityProvider\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:capacityProvider ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"capacityProvider\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"capacityProvider\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"capacityProvider\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider"

	payload := strings.NewReader("{\n  \"capacityProvider\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 28

{
  "capacityProvider": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"capacityProvider\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"capacityProvider\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"capacityProvider\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"capacityProvider\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  capacityProvider: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {capacityProvider: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"capacityProvider":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "capacityProvider": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"capacityProvider\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({capacityProvider: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {capacityProvider: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  capacityProvider: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {capacityProvider: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"capacityProvider":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"capacityProvider": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"capacityProvider\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'capacityProvider' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider', [
  'body' => '{
  "capacityProvider": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'capacityProvider' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'capacityProvider' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "capacityProvider": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "capacityProvider": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"capacityProvider\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider"

payload = { "capacityProvider": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider"

payload <- "{\n  \"capacityProvider\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"capacityProvider\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"capacityProvider\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider";

    let payload = json!({"capacityProvider": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "capacityProvider": ""
}'

echo '{
  "capacityProvider": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "capacityProvider": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["capacityProvider": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteCluster

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster

HEADERS

X-Amz-Target

BODY json

{
  "cluster": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:cluster ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster"

	payload := strings.NewReader("{\n  \"cluster\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 19

{
  "cluster": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster', [
  'body' => '{
  "cluster": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster"

payload = { "cluster": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster"

payload <- "{\n  \"cluster\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster";

    let payload = json!({"cluster": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": ""
}'

echo '{
  "cluster": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["cluster": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteCluster")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "cluster": {
    "activeServicesCount": 0,
    "clusterArn": "arn:aws:ecs:us-east-1:012345678910:cluster/my_cluster",
    "clusterName": "my_cluster",
    "pendingTasksCount": 0,
    "registeredContainerInstancesCount": 0,
    "runningTasksCount": 0,
    "status": "INACTIVE"
  }
}

POST DeleteService

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "service": "",
  "force": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"force\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:cluster ""
                                                                                                                         :service ""
                                                                                                                         :force ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"force\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"force\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"force\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"force\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 51

{
  "cluster": "",
  "service": "",
  "force": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"force\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"force\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"force\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"force\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  service: '',
  force: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', service: '', force: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","service":"","force":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "service": "",\n  "force": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"force\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', service: '', force: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', service: '', force: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  service: '',
  force: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', service: '', force: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","service":"","force":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"service": @"",
                              @"force": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"force\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'service' => '',
    'force' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService', [
  'body' => '{
  "cluster": "",
  "service": "",
  "force": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'service' => '',
  'force' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'service' => '',
  'force' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "service": "",
  "force": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "service": "",
  "force": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"force\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService"

payload = {
    "cluster": "",
    "service": "",
    "force": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService"

payload <- "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"force\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"force\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"force\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService";

    let payload = json!({
        "cluster": "",
        "service": "",
        "force": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "service": "",
  "force": ""
}'

echo '{
  "cluster": "",
  "service": "",
  "force": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "service": "",\n  "force": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "service": "",
  "force": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteService")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{}

POST DeleteTaskDefinitions

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions

HEADERS

X-Amz-Target

BODY json

{
  "taskDefinitions": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"taskDefinitions\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:taskDefinitions ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"taskDefinitions\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"taskDefinitions\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"taskDefinitions\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions"

	payload := strings.NewReader("{\n  \"taskDefinitions\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 27

{
  "taskDefinitions": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"taskDefinitions\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"taskDefinitions\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"taskDefinitions\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"taskDefinitions\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  taskDefinitions: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {taskDefinitions: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"taskDefinitions":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "taskDefinitions": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"taskDefinitions\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({taskDefinitions: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {taskDefinitions: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  taskDefinitions: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {taskDefinitions: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"taskDefinitions":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"taskDefinitions": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"taskDefinitions\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'taskDefinitions' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions', [
  'body' => '{
  "taskDefinitions": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'taskDefinitions' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'taskDefinitions' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "taskDefinitions": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "taskDefinitions": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"taskDefinitions\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions"

payload = { "taskDefinitions": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions"

payload <- "{\n  \"taskDefinitions\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"taskDefinitions\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"taskDefinitions\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions";

    let payload = json!({"taskDefinitions": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "taskDefinitions": ""
}'

echo '{
  "taskDefinitions": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "taskDefinitions": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["taskDefinitions": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskDefinitions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteTaskSet

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "service": "",
  "taskSet": "",
  "force": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"force\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:cluster ""
                                                                                                                         :service ""
                                                                                                                         :taskSet ""
                                                                                                                         :force ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"force\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"force\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"force\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"force\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 68

{
  "cluster": "",
  "service": "",
  "taskSet": "",
  "force": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"force\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"force\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"force\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"force\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  service: '',
  taskSet: '',
  force: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', service: '', taskSet: '', force: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","service":"","taskSet":"","force":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "service": "",\n  "taskSet": "",\n  "force": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"force\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', service: '', taskSet: '', force: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', service: '', taskSet: '', force: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  service: '',
  taskSet: '',
  force: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', service: '', taskSet: '', force: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","service":"","taskSet":"","force":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"service": @"",
                              @"taskSet": @"",
                              @"force": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"force\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'service' => '',
    'taskSet' => '',
    'force' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet', [
  'body' => '{
  "cluster": "",
  "service": "",
  "taskSet": "",
  "force": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'service' => '',
  'taskSet' => '',
  'force' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'service' => '',
  'taskSet' => '',
  'force' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "service": "",
  "taskSet": "",
  "force": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "service": "",
  "taskSet": "",
  "force": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"force\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet"

payload = {
    "cluster": "",
    "service": "",
    "taskSet": "",
    "force": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet"

payload <- "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"force\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"force\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"force\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet";

    let payload = json!({
        "cluster": "",
        "service": "",
        "taskSet": "",
        "force": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "service": "",
  "taskSet": "",
  "force": ""
}'

echo '{
  "cluster": "",
  "service": "",
  "taskSet": "",
  "force": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "service": "",\n  "taskSet": "",\n  "force": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "service": "",
  "taskSet": "",
  "force": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeleteTaskSet")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeregisterContainerInstance

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "containerInstance": "",
  "force": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"force\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance" {:headers {:x-amz-target ""}
                                                                                                                         :content-type :json
                                                                                                                         :form-params {:cluster ""
                                                                                                                                       :containerInstance ""
                                                                                                                                       :force ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"force\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"force\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"force\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"force\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 61

{
  "cluster": "",
  "containerInstance": "",
  "force": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"force\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"force\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"force\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"force\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  containerInstance: '',
  force: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', containerInstance: '', force: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","containerInstance":"","force":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "containerInstance": "",\n  "force": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"force\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', containerInstance: '', force: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', containerInstance: '', force: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  containerInstance: '',
  force: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', containerInstance: '', force: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","containerInstance":"","force":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"containerInstance": @"",
                              @"force": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"force\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'containerInstance' => '',
    'force' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance', [
  'body' => '{
  "cluster": "",
  "containerInstance": "",
  "force": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'containerInstance' => '',
  'force' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'containerInstance' => '',
  'force' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "containerInstance": "",
  "force": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "containerInstance": "",
  "force": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"force\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance"

payload = {
    "cluster": "",
    "containerInstance": "",
    "force": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance"

payload <- "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"force\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"force\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"force\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance";

    let payload = json!({
        "cluster": "",
        "containerInstance": "",
        "force": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "containerInstance": "",
  "force": ""
}'

echo '{
  "cluster": "",
  "containerInstance": "",
  "force": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "containerInstance": "",\n  "force": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "containerInstance": "",
  "force": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{}

POST DeregisterTaskDefinition

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition

HEADERS

X-Amz-Target

BODY json

{
  "taskDefinition": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"taskDefinition\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition" {:headers {:x-amz-target ""}
                                                                                                                      :content-type :json
                                                                                                                      :form-params {:taskDefinition ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"taskDefinition\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"taskDefinition\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"taskDefinition\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition"

	payload := strings.NewReader("{\n  \"taskDefinition\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 26

{
  "taskDefinition": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"taskDefinition\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"taskDefinition\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"taskDefinition\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"taskDefinition\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  taskDefinition: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {taskDefinition: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"taskDefinition":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "taskDefinition": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"taskDefinition\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({taskDefinition: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {taskDefinition: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  taskDefinition: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {taskDefinition: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"taskDefinition":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"taskDefinition": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"taskDefinition\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'taskDefinition' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition', [
  'body' => '{
  "taskDefinition": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'taskDefinition' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'taskDefinition' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "taskDefinition": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "taskDefinition": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"taskDefinition\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition"

payload = { "taskDefinition": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition"

payload <- "{\n  \"taskDefinition\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"taskDefinition\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"taskDefinition\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition";

    let payload = json!({"taskDefinition": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "taskDefinition": ""
}'

echo '{
  "taskDefinition": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "taskDefinition": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["taskDefinition": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeCapacityProviders

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders

HEADERS

X-Amz-Target

BODY json

{
  "capacityProviders": "",
  "include": "",
  "maxResults": "",
  "nextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"capacityProviders\": \"\",\n  \"include\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders" {:headers {:x-amz-target ""}
                                                                                                                       :content-type :json
                                                                                                                       :form-params {:capacityProviders ""
                                                                                                                                     :include ""
                                                                                                                                     :maxResults ""
                                                                                                                                     :nextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"capacityProviders\": \"\",\n  \"include\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"capacityProviders\": \"\",\n  \"include\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"capacityProviders\": \"\",\n  \"include\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders"

	payload := strings.NewReader("{\n  \"capacityProviders\": \"\",\n  \"include\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 85

{
  "capacityProviders": "",
  "include": "",
  "maxResults": "",
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"capacityProviders\": \"\",\n  \"include\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"capacityProviders\": \"\",\n  \"include\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"capacityProviders\": \"\",\n  \"include\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"capacityProviders\": \"\",\n  \"include\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  capacityProviders: '',
  include: '',
  maxResults: '',
  nextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {capacityProviders: '', include: '', maxResults: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"capacityProviders":"","include":"","maxResults":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "capacityProviders": "",\n  "include": "",\n  "maxResults": "",\n  "nextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"capacityProviders\": \"\",\n  \"include\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({capacityProviders: '', include: '', maxResults: '', nextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {capacityProviders: '', include: '', maxResults: '', nextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  capacityProviders: '',
  include: '',
  maxResults: '',
  nextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {capacityProviders: '', include: '', maxResults: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"capacityProviders":"","include":"","maxResults":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"capacityProviders": @"",
                              @"include": @"",
                              @"maxResults": @"",
                              @"nextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"capacityProviders\": \"\",\n  \"include\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'capacityProviders' => '',
    'include' => '',
    'maxResults' => '',
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders', [
  'body' => '{
  "capacityProviders": "",
  "include": "",
  "maxResults": "",
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'capacityProviders' => '',
  'include' => '',
  'maxResults' => '',
  'nextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'capacityProviders' => '',
  'include' => '',
  'maxResults' => '',
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "capacityProviders": "",
  "include": "",
  "maxResults": "",
  "nextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "capacityProviders": "",
  "include": "",
  "maxResults": "",
  "nextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"capacityProviders\": \"\",\n  \"include\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders"

payload = {
    "capacityProviders": "",
    "include": "",
    "maxResults": "",
    "nextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders"

payload <- "{\n  \"capacityProviders\": \"\",\n  \"include\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"capacityProviders\": \"\",\n  \"include\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"capacityProviders\": \"\",\n  \"include\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders";

    let payload = json!({
        "capacityProviders": "",
        "include": "",
        "maxResults": "",
        "nextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "capacityProviders": "",
  "include": "",
  "maxResults": "",
  "nextToken": ""
}'

echo '{
  "capacityProviders": "",
  "include": "",
  "maxResults": "",
  "nextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "capacityProviders": "",\n  "include": "",\n  "maxResults": "",\n  "nextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "capacityProviders": "",
  "include": "",
  "maxResults": "",
  "nextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeClusters

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters

HEADERS

X-Amz-Target

BODY json

{
  "clusters": "",
  "include": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"clusters\": \"\",\n  \"include\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:clusters ""
                                                                                                                            :include ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"clusters\": \"\",\n  \"include\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"clusters\": \"\",\n  \"include\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"clusters\": \"\",\n  \"include\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters"

	payload := strings.NewReader("{\n  \"clusters\": \"\",\n  \"include\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 37

{
  "clusters": "",
  "include": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"clusters\": \"\",\n  \"include\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"clusters\": \"\",\n  \"include\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"clusters\": \"\",\n  \"include\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"clusters\": \"\",\n  \"include\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  clusters: '',
  include: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {clusters: '', include: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"clusters":"","include":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "clusters": "",\n  "include": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"clusters\": \"\",\n  \"include\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({clusters: '', include: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {clusters: '', include: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  clusters: '',
  include: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {clusters: '', include: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"clusters":"","include":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"clusters": @"",
                              @"include": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"clusters\": \"\",\n  \"include\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'clusters' => '',
    'include' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters', [
  'body' => '{
  "clusters": "",
  "include": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'clusters' => '',
  'include' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'clusters' => '',
  'include' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clusters": "",
  "include": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clusters": "",
  "include": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"clusters\": \"\",\n  \"include\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters"

payload = {
    "clusters": "",
    "include": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters"

payload <- "{\n  \"clusters\": \"\",\n  \"include\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"clusters\": \"\",\n  \"include\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"clusters\": \"\",\n  \"include\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters";

    let payload = json!({
        "clusters": "",
        "include": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "clusters": "",
  "include": ""
}'

echo '{
  "clusters": "",
  "include": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "clusters": "",\n  "include": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "clusters": "",
  "include": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeClusters")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "clusters": [
    {
      "clusterArn": "arn:aws:ecs:us-east-1:aws_account_id:cluster/default",
      "clusterName": "default",
      "status": "ACTIVE"
    }
  ],
  "failures": []
}

POST DescribeContainerInstances

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "containerInstances": "",
  "include": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"include\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances" {:headers {:x-amz-target ""}
                                                                                                                        :content-type :json
                                                                                                                        :form-params {:cluster ""
                                                                                                                                      :containerInstances ""
                                                                                                                                      :include ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"include\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"include\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"include\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"include\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 64

{
  "cluster": "",
  "containerInstances": "",
  "include": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"include\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"include\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"include\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"include\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  containerInstances: '',
  include: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', containerInstances: '', include: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","containerInstances":"","include":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "containerInstances": "",\n  "include": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"include\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', containerInstances: '', include: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', containerInstances: '', include: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  containerInstances: '',
  include: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', containerInstances: '', include: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","containerInstances":"","include":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"containerInstances": @"",
                              @"include": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"include\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'containerInstances' => '',
    'include' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances', [
  'body' => '{
  "cluster": "",
  "containerInstances": "",
  "include": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'containerInstances' => '',
  'include' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'containerInstances' => '',
  'include' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "containerInstances": "",
  "include": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "containerInstances": "",
  "include": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"include\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances"

payload = {
    "cluster": "",
    "containerInstances": "",
    "include": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances"

payload <- "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"include\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"include\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"include\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances";

    let payload = json!({
        "cluster": "",
        "containerInstances": "",
        "include": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "containerInstances": "",
  "include": ""
}'

echo '{
  "cluster": "",
  "containerInstances": "",
  "include": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "containerInstances": "",\n  "include": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "containerInstances": "",
  "include": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeContainerInstances")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "containerInstances": [
    {
      "agentConnected": true,
      "containerInstanceArn": "arn:aws:ecs:us-east-1:012345678910:container-instance/f2756532-8f13-4d53-87c9-aed50dc94cd7",
      "ec2InstanceId": "i-807f3249",
      "pendingTasksCount": 0,
      "registeredResources": [
        {
          "name": "CPU",
          "type": "INTEGER",
          "doubleValue": 0,
          "integerValue": 2048,
          "longValue": 0
        },
        {
          "name": "MEMORY",
          "type": "INTEGER",
          "doubleValue": 0,
          "integerValue": 3768,
          "longValue": 0
        },
        {
          "name": "PORTS",
          "type": "STRINGSET",
          "doubleValue": 0,
          "integerValue": 0,
          "longValue": 0,
          "stringSetValue": [
            "2376",
            "22",
            "51678",
            "2375"
          ]
        }
      ],
      "remainingResources": [
        {
          "name": "CPU",
          "type": "INTEGER",
          "doubleValue": 0,
          "integerValue": 1948,
          "longValue": 0
        },
        {
          "name": "MEMORY",
          "type": "INTEGER",
          "doubleValue": 0,
          "integerValue": 3668,
          "longValue": 0
        },
        {
          "name": "PORTS",
          "type": "STRINGSET",
          "doubleValue": 0,
          "integerValue": 0,
          "longValue": 0,
          "stringSetValue": [
            "2376",
            "22",
            "80",
            "51678",
            "2375"
          ]
        }
      ],
      "runningTasksCount": 1,
      "status": "ACTIVE"
    }
  ],
  "failures": []
}

POST DescribeServices

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "services": "",
  "include": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"services\": \"\",\n  \"include\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:cluster ""
                                                                                                                            :services ""
                                                                                                                            :include ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"services\": \"\",\n  \"include\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"services\": \"\",\n  \"include\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"services\": \"\",\n  \"include\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"services\": \"\",\n  \"include\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 54

{
  "cluster": "",
  "services": "",
  "include": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"services\": \"\",\n  \"include\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"services\": \"\",\n  \"include\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"services\": \"\",\n  \"include\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"services\": \"\",\n  \"include\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  services: '',
  include: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', services: '', include: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","services":"","include":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "services": "",\n  "include": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"services\": \"\",\n  \"include\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', services: '', include: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', services: '', include: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  services: '',
  include: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', services: '', include: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","services":"","include":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"services": @"",
                              @"include": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"services\": \"\",\n  \"include\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'services' => '',
    'include' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices', [
  'body' => '{
  "cluster": "",
  "services": "",
  "include": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'services' => '',
  'include' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'services' => '',
  'include' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "services": "",
  "include": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "services": "",
  "include": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"services\": \"\",\n  \"include\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices"

payload = {
    "cluster": "",
    "services": "",
    "include": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices"

payload <- "{\n  \"cluster\": \"\",\n  \"services\": \"\",\n  \"include\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"services\": \"\",\n  \"include\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"services\": \"\",\n  \"include\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices";

    let payload = json!({
        "cluster": "",
        "services": "",
        "include": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "services": "",
  "include": ""
}'

echo '{
  "cluster": "",
  "services": "",
  "include": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "services": "",\n  "include": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "services": "",
  "include": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeServices")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "failures": [],
  "services": [
    {
      "clusterArn": "arn:aws:ecs:us-east-1:012345678910:cluster/default",
      "createdAt": "2016-08-29T16:25:52.130Z",
      "deploymentConfiguration": {
        "maximumPercent": 200,
        "minimumHealthyPercent": 100
      },
      "deployments": [
        {
          "createdAt": "2016-08-29T16:25:52.130Z",
          "desiredCount": 1,
          "id": "ecs-svc/9223370564341623665",
          "pendingCount": 0,
          "runningCount": 0,
          "status": "PRIMARY",
          "taskDefinition": "arn:aws:ecs:us-east-1:012345678910:task-definition/hello_world:6",
          "updatedAt": "2016-08-29T16:25:52.130Z"
        }
      ],
      "desiredCount": 1,
      "events": [
        {
          "createdAt": "2016-08-29T16:25:58.520Z",
          "id": "38c285e5-d335-4b68-8b15-e46dedc8e88d",
          "message": "(service ecs-simple-service) was unable to place a task because no container instance met all of its requirements. The closest matching (container-instance 3f4de1c5-ffdd-4954-af7e-75b4be0c8841) is already using a port required by your task. For more information, see the Troubleshooting section of the Amazon ECS Developer Guide."
        }
      ],
      "loadBalancers": [],
      "pendingCount": 0,
      "runningCount": 0,
      "serviceArn": "arn:aws:ecs:us-east-1:012345678910:service/ecs-simple-service",
      "serviceName": "ecs-simple-service",
      "status": "ACTIVE",
      "taskDefinition": "arn:aws:ecs:us-east-1:012345678910:task-definition/hello_world:6"
    }
  ]
}

POST DescribeTaskDefinition

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition

HEADERS

X-Amz-Target

BODY json

{
  "taskDefinition": "",
  "include": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"taskDefinition\": \"\",\n  \"include\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:taskDefinition ""
                                                                                                                                  :include ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"taskDefinition\": \"\",\n  \"include\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"taskDefinition\": \"\",\n  \"include\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"taskDefinition\": \"\",\n  \"include\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition"

	payload := strings.NewReader("{\n  \"taskDefinition\": \"\",\n  \"include\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 43

{
  "taskDefinition": "",
  "include": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"taskDefinition\": \"\",\n  \"include\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"taskDefinition\": \"\",\n  \"include\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"taskDefinition\": \"\",\n  \"include\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"taskDefinition\": \"\",\n  \"include\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  taskDefinition: '',
  include: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {taskDefinition: '', include: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"taskDefinition":"","include":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "taskDefinition": "",\n  "include": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"taskDefinition\": \"\",\n  \"include\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({taskDefinition: '', include: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {taskDefinition: '', include: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  taskDefinition: '',
  include: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {taskDefinition: '', include: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"taskDefinition":"","include":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"taskDefinition": @"",
                              @"include": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"taskDefinition\": \"\",\n  \"include\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'taskDefinition' => '',
    'include' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition', [
  'body' => '{
  "taskDefinition": "",
  "include": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'taskDefinition' => '',
  'include' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'taskDefinition' => '',
  'include' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "taskDefinition": "",
  "include": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "taskDefinition": "",
  "include": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"taskDefinition\": \"\",\n  \"include\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition"

payload = {
    "taskDefinition": "",
    "include": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition"

payload <- "{\n  \"taskDefinition\": \"\",\n  \"include\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"taskDefinition\": \"\",\n  \"include\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"taskDefinition\": \"\",\n  \"include\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition";

    let payload = json!({
        "taskDefinition": "",
        "include": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "taskDefinition": "",
  "include": ""
}'

echo '{
  "taskDefinition": "",
  "include": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "taskDefinition": "",\n  "include": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "taskDefinition": "",
  "include": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "taskDefinition": {
    "containerDefinitions": [
      {
        "name": "wordpress",
        "cpu": 10,
        "environment": [],
        "essential": true,
        "image": "wordpress",
        "links": [
          "mysql"
        ],
        "memory": 500,
        "mountPoints": [],
        "portMappings": [
          {
            "containerPort": 80,
            "hostPort": 80
          }
        ],
        "volumesFrom": []
      },
      {
        "name": "mysql",
        "cpu": 10,
        "environment": [
          {
            "name": "MYSQL_ROOT_PASSWORD",
            "value": "password"
          }
        ],
        "essential": true,
        "image": "mysql",
        "memory": 500,
        "mountPoints": [],
        "portMappings": [],
        "volumesFrom": []
      }
    ],
    "family": "hello_world",
    "revision": 8,
    "taskDefinitionArn": "arn:aws:ecs:us-east-1::task-definition/hello_world:8",
    "volumes": []
  }
}

POST DescribeTaskSets

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "service": "",
  "taskSets": "",
  "include": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSets\": \"\",\n  \"include\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:cluster ""
                                                                                                                            :service ""
                                                                                                                            :taskSets ""
                                                                                                                            :include ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSets\": \"\",\n  \"include\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSets\": \"\",\n  \"include\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSets\": \"\",\n  \"include\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSets\": \"\",\n  \"include\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 71

{
  "cluster": "",
  "service": "",
  "taskSets": "",
  "include": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSets\": \"\",\n  \"include\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSets\": \"\",\n  \"include\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSets\": \"\",\n  \"include\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSets\": \"\",\n  \"include\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  service: '',
  taskSets: '',
  include: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', service: '', taskSets: '', include: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","service":"","taskSets":"","include":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "service": "",\n  "taskSets": "",\n  "include": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSets\": \"\",\n  \"include\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', service: '', taskSets: '', include: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', service: '', taskSets: '', include: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  service: '',
  taskSets: '',
  include: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', service: '', taskSets: '', include: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","service":"","taskSets":"","include":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"service": @"",
                              @"taskSets": @"",
                              @"include": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSets\": \"\",\n  \"include\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'service' => '',
    'taskSets' => '',
    'include' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets', [
  'body' => '{
  "cluster": "",
  "service": "",
  "taskSets": "",
  "include": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'service' => '',
  'taskSets' => '',
  'include' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'service' => '',
  'taskSets' => '',
  'include' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "service": "",
  "taskSets": "",
  "include": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "service": "",
  "taskSets": "",
  "include": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSets\": \"\",\n  \"include\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets"

payload = {
    "cluster": "",
    "service": "",
    "taskSets": "",
    "include": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets"

payload <- "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSets\": \"\",\n  \"include\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSets\": \"\",\n  \"include\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSets\": \"\",\n  \"include\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets";

    let payload = json!({
        "cluster": "",
        "service": "",
        "taskSets": "",
        "include": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "service": "",
  "taskSets": "",
  "include": ""
}'

echo '{
  "cluster": "",
  "service": "",
  "taskSets": "",
  "include": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "service": "",\n  "taskSets": "",\n  "include": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "service": "",
  "taskSets": "",
  "include": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTaskSets")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeTasks

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "tasks": "",
  "include": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"include\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:cluster ""
                                                                                                                         :tasks ""
                                                                                                                         :include ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"include\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"include\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"include\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"include\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 51

{
  "cluster": "",
  "tasks": "",
  "include": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"include\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"include\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"include\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"include\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  tasks: '',
  include: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', tasks: '', include: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","tasks":"","include":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "tasks": "",\n  "include": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"include\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', tasks: '', include: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', tasks: '', include: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  tasks: '',
  include: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', tasks: '', include: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","tasks":"","include":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"tasks": @"",
                              @"include": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"include\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'tasks' => '',
    'include' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks', [
  'body' => '{
  "cluster": "",
  "tasks": "",
  "include": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'tasks' => '',
  'include' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'tasks' => '',
  'include' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "tasks": "",
  "include": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "tasks": "",
  "include": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"include\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks"

payload = {
    "cluster": "",
    "tasks": "",
    "include": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks"

payload <- "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"include\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"include\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"include\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks";

    let payload = json!({
        "cluster": "",
        "tasks": "",
        "include": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "tasks": "",
  "include": ""
}'

echo '{
  "cluster": "",
  "tasks": "",
  "include": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "tasks": "",\n  "include": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "tasks": "",
  "include": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DescribeTasks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "failures": [],
  "tasks": [
    {
      "clusterArn": "arn:aws:ecs:::cluster/default",
      "containerInstanceArn": "arn:aws:ecs:::container-instance/18f9eda5-27d7-4c19-b133-45adc516e8fb",
      "containers": [
        {
          "name": "ecs-demo",
          "containerArn": "arn:aws:ecs:::container/7c01765b-c588-45b3-8290-4ba38bd6c5a6",
          "lastStatus": "RUNNING",
          "networkBindings": [
            {
              "bindIP": "0.0.0.0",
              "containerPort": 80,
              "hostPort": 80
            }
          ],
          "taskArn": "arn:aws:ecs:::task/c5cba4eb-5dad-405e-96db-71ef8eefe6a8"
        }
      ],
      "desiredStatus": "RUNNING",
      "lastStatus": "RUNNING",
      "overrides": {
        "containerOverrides": [
          {
            "name": "ecs-demo"
          }
        ]
      },
      "startedBy": "ecs-svc/9223370608528463088",
      "taskArn": "arn:aws:ecs:::task/c5cba4eb-5dad-405e-96db-71ef8eefe6a8",
      "taskDefinitionArn": "arn:aws:ecs:::task-definition/amazon-ecs-sample:1"
    }
  ]
}

POST DiscoverPollEndpoint

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint

HEADERS

X-Amz-Target

BODY json

{
  "containerInstance": "",
  "cluster": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"containerInstance\": \"\",\n  \"cluster\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint" {:headers {:x-amz-target ""}
                                                                                                                  :content-type :json
                                                                                                                  :form-params {:containerInstance ""
                                                                                                                                :cluster ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"containerInstance\": \"\",\n  \"cluster\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"containerInstance\": \"\",\n  \"cluster\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"containerInstance\": \"\",\n  \"cluster\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint"

	payload := strings.NewReader("{\n  \"containerInstance\": \"\",\n  \"cluster\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 46

{
  "containerInstance": "",
  "cluster": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"containerInstance\": \"\",\n  \"cluster\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"containerInstance\": \"\",\n  \"cluster\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"containerInstance\": \"\",\n  \"cluster\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"containerInstance\": \"\",\n  \"cluster\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  containerInstance: '',
  cluster: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {containerInstance: '', cluster: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"containerInstance":"","cluster":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "containerInstance": "",\n  "cluster": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"containerInstance\": \"\",\n  \"cluster\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({containerInstance: '', cluster: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {containerInstance: '', cluster: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  containerInstance: '',
  cluster: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {containerInstance: '', cluster: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"containerInstance":"","cluster":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"containerInstance": @"",
                              @"cluster": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"containerInstance\": \"\",\n  \"cluster\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'containerInstance' => '',
    'cluster' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint', [
  'body' => '{
  "containerInstance": "",
  "cluster": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'containerInstance' => '',
  'cluster' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'containerInstance' => '',
  'cluster' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "containerInstance": "",
  "cluster": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "containerInstance": "",
  "cluster": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"containerInstance\": \"\",\n  \"cluster\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint"

payload = {
    "containerInstance": "",
    "cluster": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint"

payload <- "{\n  \"containerInstance\": \"\",\n  \"cluster\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"containerInstance\": \"\",\n  \"cluster\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"containerInstance\": \"\",\n  \"cluster\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint";

    let payload = json!({
        "containerInstance": "",
        "cluster": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "containerInstance": "",
  "cluster": ""
}'

echo '{
  "containerInstance": "",
  "cluster": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "containerInstance": "",\n  "cluster": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "containerInstance": "",
  "cluster": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ExecuteCommand

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "container": "",
  "command": "",
  "interactive": "",
  "task": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"container\": \"\",\n  \"command\": \"\",\n  \"interactive\": \"\",\n  \"task\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:cluster ""
                                                                                                                          :container ""
                                                                                                                          :command ""
                                                                                                                          :interactive ""
                                                                                                                          :task ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"container\": \"\",\n  \"command\": \"\",\n  \"interactive\": \"\",\n  \"task\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"container\": \"\",\n  \"command\": \"\",\n  \"interactive\": \"\",\n  \"task\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"container\": \"\",\n  \"command\": \"\",\n  \"interactive\": \"\",\n  \"task\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"container\": \"\",\n  \"command\": \"\",\n  \"interactive\": \"\",\n  \"task\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 90

{
  "cluster": "",
  "container": "",
  "command": "",
  "interactive": "",
  "task": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"container\": \"\",\n  \"command\": \"\",\n  \"interactive\": \"\",\n  \"task\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"container\": \"\",\n  \"command\": \"\",\n  \"interactive\": \"\",\n  \"task\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"container\": \"\",\n  \"command\": \"\",\n  \"interactive\": \"\",\n  \"task\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"container\": \"\",\n  \"command\": \"\",\n  \"interactive\": \"\",\n  \"task\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  container: '',
  command: '',
  interactive: '',
  task: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', container: '', command: '', interactive: '', task: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","container":"","command":"","interactive":"","task":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "container": "",\n  "command": "",\n  "interactive": "",\n  "task": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"container\": \"\",\n  \"command\": \"\",\n  \"interactive\": \"\",\n  \"task\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', container: '', command: '', interactive: '', task: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', container: '', command: '', interactive: '', task: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  container: '',
  command: '',
  interactive: '',
  task: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', container: '', command: '', interactive: '', task: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","container":"","command":"","interactive":"","task":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"container": @"",
                              @"command": @"",
                              @"interactive": @"",
                              @"task": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"container\": \"\",\n  \"command\": \"\",\n  \"interactive\": \"\",\n  \"task\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'container' => '',
    'command' => '',
    'interactive' => '',
    'task' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand', [
  'body' => '{
  "cluster": "",
  "container": "",
  "command": "",
  "interactive": "",
  "task": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'container' => '',
  'command' => '',
  'interactive' => '',
  'task' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'container' => '',
  'command' => '',
  'interactive' => '',
  'task' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "container": "",
  "command": "",
  "interactive": "",
  "task": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "container": "",
  "command": "",
  "interactive": "",
  "task": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"container\": \"\",\n  \"command\": \"\",\n  \"interactive\": \"\",\n  \"task\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand"

payload = {
    "cluster": "",
    "container": "",
    "command": "",
    "interactive": "",
    "task": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand"

payload <- "{\n  \"cluster\": \"\",\n  \"container\": \"\",\n  \"command\": \"\",\n  \"interactive\": \"\",\n  \"task\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"container\": \"\",\n  \"command\": \"\",\n  \"interactive\": \"\",\n  \"task\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"container\": \"\",\n  \"command\": \"\",\n  \"interactive\": \"\",\n  \"task\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand";

    let payload = json!({
        "cluster": "",
        "container": "",
        "command": "",
        "interactive": "",
        "task": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "container": "",
  "command": "",
  "interactive": "",
  "task": ""
}'

echo '{
  "cluster": "",
  "container": "",
  "command": "",
  "interactive": "",
  "task": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "container": "",\n  "command": "",\n  "interactive": "",\n  "task": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "container": "",
  "command": "",
  "interactive": "",
  "task": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ExecuteCommand")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetTaskProtection

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "tasks": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"tasks\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:cluster ""
                                                                                                                             :tasks ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"tasks\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"tasks\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"tasks\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"tasks\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "cluster": "",
  "tasks": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"tasks\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"tasks\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"tasks\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"tasks\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  tasks: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', tasks: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","tasks":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "tasks": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"tasks\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', tasks: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', tasks: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  tasks: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', tasks: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","tasks":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"tasks": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"tasks\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'tasks' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection', [
  'body' => '{
  "cluster": "",
  "tasks": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'tasks' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'tasks' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "tasks": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "tasks": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"tasks\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection"

payload = {
    "cluster": "",
    "tasks": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection"

payload <- "{\n  \"cluster\": \"\",\n  \"tasks\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"tasks\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"tasks\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection";

    let payload = json!({
        "cluster": "",
        "tasks": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "tasks": ""
}'

echo '{
  "cluster": "",
  "tasks": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "tasks": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "tasks": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.GetTaskProtection")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "failures": [],
  "protectedTasks": [
    {
      "expirationDate": "2022-11-02T06:56:32.553Z",
      "protectionEnabled": true,
      "taskArn": "arn:aws:ecs:us-west-2:012345678910:task/b8b1cf532d0e46ba8d44a40d1de16772"
    }
  ]
}

POST ListAccountSettings

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings

HEADERS

X-Amz-Target

BODY json

{
  "name": "",
  "value": "",
  "principalArn": "",
  "effectiveSettings": "",
  "nextToken": "",
  "maxResults": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\",\n  \"effectiveSettings\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:name ""
                                                                                                                               :value ""
                                                                                                                               :principalArn ""
                                                                                                                               :effectiveSettings ""
                                                                                                                               :nextToken ""
                                                                                                                               :maxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\",\n  \"effectiveSettings\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\",\n  \"effectiveSettings\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\",\n  \"effectiveSettings\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\",\n  \"effectiveSettings\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 119

{
  "name": "",
  "value": "",
  "principalArn": "",
  "effectiveSettings": "",
  "nextToken": "",
  "maxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\",\n  \"effectiveSettings\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\",\n  \"effectiveSettings\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\",\n  \"effectiveSettings\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\",\n  \"effectiveSettings\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  value: '',
  principalArn: '',
  effectiveSettings: '',
  nextToken: '',
  maxResults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    name: '',
    value: '',
    principalArn: '',
    effectiveSettings: '',
    nextToken: '',
    maxResults: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","value":"","principalArn":"","effectiveSettings":"","nextToken":"","maxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "value": "",\n  "principalArn": "",\n  "effectiveSettings": "",\n  "nextToken": "",\n  "maxResults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\",\n  \"effectiveSettings\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  name: '',
  value: '',
  principalArn: '',
  effectiveSettings: '',
  nextToken: '',
  maxResults: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    name: '',
    value: '',
    principalArn: '',
    effectiveSettings: '',
    nextToken: '',
    maxResults: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: '',
  value: '',
  principalArn: '',
  effectiveSettings: '',
  nextToken: '',
  maxResults: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    name: '',
    value: '',
    principalArn: '',
    effectiveSettings: '',
    nextToken: '',
    maxResults: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","value":"","principalArn":"","effectiveSettings":"","nextToken":"","maxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"",
                              @"value": @"",
                              @"principalArn": @"",
                              @"effectiveSettings": @"",
                              @"nextToken": @"",
                              @"maxResults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\",\n  \"effectiveSettings\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'value' => '',
    'principalArn' => '',
    'effectiveSettings' => '',
    'nextToken' => '',
    'maxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings', [
  'body' => '{
  "name": "",
  "value": "",
  "principalArn": "",
  "effectiveSettings": "",
  "nextToken": "",
  "maxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'value' => '',
  'principalArn' => '',
  'effectiveSettings' => '',
  'nextToken' => '',
  'maxResults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => '',
  'value' => '',
  'principalArn' => '',
  'effectiveSettings' => '',
  'nextToken' => '',
  'maxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "value": "",
  "principalArn": "",
  "effectiveSettings": "",
  "nextToken": "",
  "maxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "value": "",
  "principalArn": "",
  "effectiveSettings": "",
  "nextToken": "",
  "maxResults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\",\n  \"effectiveSettings\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings"

payload = {
    "name": "",
    "value": "",
    "principalArn": "",
    "effectiveSettings": "",
    "nextToken": "",
    "maxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings"

payload <- "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\",\n  \"effectiveSettings\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\",\n  \"effectiveSettings\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\",\n  \"effectiveSettings\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings";

    let payload = json!({
        "name": "",
        "value": "",
        "principalArn": "",
        "effectiveSettings": "",
        "nextToken": "",
        "maxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": "",
  "value": "",
  "principalArn": "",
  "effectiveSettings": "",
  "nextToken": "",
  "maxResults": ""
}'

echo '{
  "name": "",
  "value": "",
  "principalArn": "",
  "effectiveSettings": "",
  "nextToken": "",
  "maxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "value": "",\n  "principalArn": "",\n  "effectiveSettings": "",\n  "nextToken": "",\n  "maxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "name": "",
  "value": "",
  "principalArn": "",
  "effectiveSettings": "",
  "nextToken": "",
  "maxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAccountSettings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "settings": [
    {
      "name": "containerInstanceLongArnFormat",
      "value": "disabled",
      "principalArn": "arn:aws:iam:::user/principalName"
    },
    {
      "name": "serviceLongArnFormat",
      "value": "enabled",
      "principalArn": "arn:aws:iam:::user/principalName"
    },
    {
      "name": "taskLongArnFormat",
      "value": "disabled",
      "principalArn": "arn:aws:iam:::user/principalName"
    }
  ]
}

POST ListAttributes

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "targetType": "",
  "attributeName": "",
  "attributeValue": "",
  "nextToken": "",
  "maxResults": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"targetType\": \"\",\n  \"attributeName\": \"\",\n  \"attributeValue\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:cluster ""
                                                                                                                          :targetType ""
                                                                                                                          :attributeName ""
                                                                                                                          :attributeValue ""
                                                                                                                          :nextToken ""
                                                                                                                          :maxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"targetType\": \"\",\n  \"attributeName\": \"\",\n  \"attributeValue\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"targetType\": \"\",\n  \"attributeName\": \"\",\n  \"attributeValue\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"targetType\": \"\",\n  \"attributeName\": \"\",\n  \"attributeValue\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"targetType\": \"\",\n  \"attributeName\": \"\",\n  \"attributeValue\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 125

{
  "cluster": "",
  "targetType": "",
  "attributeName": "",
  "attributeValue": "",
  "nextToken": "",
  "maxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"targetType\": \"\",\n  \"attributeName\": \"\",\n  \"attributeValue\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"targetType\": \"\",\n  \"attributeName\": \"\",\n  \"attributeValue\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"targetType\": \"\",\n  \"attributeName\": \"\",\n  \"attributeValue\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"targetType\": \"\",\n  \"attributeName\": \"\",\n  \"attributeValue\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  targetType: '',
  attributeName: '',
  attributeValue: '',
  nextToken: '',
  maxResults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    cluster: '',
    targetType: '',
    attributeName: '',
    attributeValue: '',
    nextToken: '',
    maxResults: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","targetType":"","attributeName":"","attributeValue":"","nextToken":"","maxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "targetType": "",\n  "attributeName": "",\n  "attributeValue": "",\n  "nextToken": "",\n  "maxResults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"targetType\": \"\",\n  \"attributeName\": \"\",\n  \"attributeValue\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  cluster: '',
  targetType: '',
  attributeName: '',
  attributeValue: '',
  nextToken: '',
  maxResults: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    cluster: '',
    targetType: '',
    attributeName: '',
    attributeValue: '',
    nextToken: '',
    maxResults: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  targetType: '',
  attributeName: '',
  attributeValue: '',
  nextToken: '',
  maxResults: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    cluster: '',
    targetType: '',
    attributeName: '',
    attributeValue: '',
    nextToken: '',
    maxResults: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","targetType":"","attributeName":"","attributeValue":"","nextToken":"","maxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"targetType": @"",
                              @"attributeName": @"",
                              @"attributeValue": @"",
                              @"nextToken": @"",
                              @"maxResults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"targetType\": \"\",\n  \"attributeName\": \"\",\n  \"attributeValue\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'targetType' => '',
    'attributeName' => '',
    'attributeValue' => '',
    'nextToken' => '',
    'maxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes', [
  'body' => '{
  "cluster": "",
  "targetType": "",
  "attributeName": "",
  "attributeValue": "",
  "nextToken": "",
  "maxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'targetType' => '',
  'attributeName' => '',
  'attributeValue' => '',
  'nextToken' => '',
  'maxResults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'targetType' => '',
  'attributeName' => '',
  'attributeValue' => '',
  'nextToken' => '',
  'maxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "targetType": "",
  "attributeName": "",
  "attributeValue": "",
  "nextToken": "",
  "maxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "targetType": "",
  "attributeName": "",
  "attributeValue": "",
  "nextToken": "",
  "maxResults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"targetType\": \"\",\n  \"attributeName\": \"\",\n  \"attributeValue\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes"

payload = {
    "cluster": "",
    "targetType": "",
    "attributeName": "",
    "attributeValue": "",
    "nextToken": "",
    "maxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes"

payload <- "{\n  \"cluster\": \"\",\n  \"targetType\": \"\",\n  \"attributeName\": \"\",\n  \"attributeValue\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"targetType\": \"\",\n  \"attributeName\": \"\",\n  \"attributeValue\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"targetType\": \"\",\n  \"attributeName\": \"\",\n  \"attributeValue\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes";

    let payload = json!({
        "cluster": "",
        "targetType": "",
        "attributeName": "",
        "attributeValue": "",
        "nextToken": "",
        "maxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "targetType": "",
  "attributeName": "",
  "attributeValue": "",
  "nextToken": "",
  "maxResults": ""
}'

echo '{
  "cluster": "",
  "targetType": "",
  "attributeName": "",
  "attributeValue": "",
  "nextToken": "",
  "maxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "targetType": "",\n  "attributeName": "",\n  "attributeValue": "",\n  "nextToken": "",\n  "maxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "targetType": "",
  "attributeName": "",
  "attributeValue": "",
  "nextToken": "",
  "maxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListAttributes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListClusters

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters

HEADERS

X-Amz-Target

BODY json

{
  "nextToken": "",
  "maxResults": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:nextToken ""
                                                                                                                        :maxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters"

	payload := strings.NewReader("{\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 41

{
  "nextToken": "",
  "maxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  nextToken: '',
  maxResults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {nextToken: '', maxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"nextToken":"","maxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "nextToken": "",\n  "maxResults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({nextToken: '', maxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {nextToken: '', maxResults: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  nextToken: '',
  maxResults: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {nextToken: '', maxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"nextToken":"","maxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"nextToken": @"",
                              @"maxResults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'nextToken' => '',
    'maxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters', [
  'body' => '{
  "nextToken": "",
  "maxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'nextToken' => '',
  'maxResults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'nextToken' => '',
  'maxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nextToken": "",
  "maxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nextToken": "",
  "maxResults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters"

payload = {
    "nextToken": "",
    "maxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters"

payload <- "{\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters";

    let payload = json!({
        "nextToken": "",
        "maxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "nextToken": "",
  "maxResults": ""
}'

echo '{
  "nextToken": "",
  "maxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "nextToken": "",\n  "maxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "nextToken": "",
  "maxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListClusters")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "clusterArns": [
    "arn:aws:ecs:us-east-1::cluster/test",
    "arn:aws:ecs:us-east-1::cluster/default"
  ]
}

POST ListContainerInstances

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "filter": "",
  "nextToken": "",
  "maxResults": "",
  "status": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"filter\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:cluster ""
                                                                                                                                  :filter ""
                                                                                                                                  :nextToken ""
                                                                                                                                  :maxResults ""
                                                                                                                                  :status ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"filter\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"status\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"filter\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"filter\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"filter\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"status\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 90

{
  "cluster": "",
  "filter": "",
  "nextToken": "",
  "maxResults": "",
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"filter\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"filter\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"filter\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"filter\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  filter: '',
  nextToken: '',
  maxResults: '',
  status: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', filter: '', nextToken: '', maxResults: '', status: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","filter":"","nextToken":"","maxResults":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "filter": "",\n  "nextToken": "",\n  "maxResults": "",\n  "status": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"filter\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', filter: '', nextToken: '', maxResults: '', status: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', filter: '', nextToken: '', maxResults: '', status: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  filter: '',
  nextToken: '',
  maxResults: '',
  status: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', filter: '', nextToken: '', maxResults: '', status: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","filter":"","nextToken":"","maxResults":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"filter": @"",
                              @"nextToken": @"",
                              @"maxResults": @"",
                              @"status": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"filter\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"status\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'filter' => '',
    'nextToken' => '',
    'maxResults' => '',
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances', [
  'body' => '{
  "cluster": "",
  "filter": "",
  "nextToken": "",
  "maxResults": "",
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'filter' => '',
  'nextToken' => '',
  'maxResults' => '',
  'status' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'filter' => '',
  'nextToken' => '',
  'maxResults' => '',
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "filter": "",
  "nextToken": "",
  "maxResults": "",
  "status": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "filter": "",
  "nextToken": "",
  "maxResults": "",
  "status": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"filter\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"status\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances"

payload = {
    "cluster": "",
    "filter": "",
    "nextToken": "",
    "maxResults": "",
    "status": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances"

payload <- "{\n  \"cluster\": \"\",\n  \"filter\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"status\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"filter\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"status\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"filter\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"status\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances";

    let payload = json!({
        "cluster": "",
        "filter": "",
        "nextToken": "",
        "maxResults": "",
        "status": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "filter": "",
  "nextToken": "",
  "maxResults": "",
  "status": ""
}'

echo '{
  "cluster": "",
  "filter": "",
  "nextToken": "",
  "maxResults": "",
  "status": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "filter": "",\n  "nextToken": "",\n  "maxResults": "",\n  "status": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "filter": "",
  "nextToken": "",
  "maxResults": "",
  "status": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListContainerInstances")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "containerInstanceArns": [
    "arn:aws:ecs:us-east-1::container-instance/f6bbb147-5370-4ace-8c73-c7181ded911f",
    "arn:aws:ecs:us-east-1::container-instance/ffe3d344-77e2-476c-a4d0-bf560ad50acb"
  ]
}

POST ListServices

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "nextToken": "",
  "maxResults": "",
  "launchType": "",
  "schedulingStrategy": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"launchType\": \"\",\n  \"schedulingStrategy\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:cluster ""
                                                                                                                        :nextToken ""
                                                                                                                        :maxResults ""
                                                                                                                        :launchType ""
                                                                                                                        :schedulingStrategy ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"launchType\": \"\",\n  \"schedulingStrategy\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"launchType\": \"\",\n  \"schedulingStrategy\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"launchType\": \"\",\n  \"schedulingStrategy\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"launchType\": \"\",\n  \"schedulingStrategy\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 106

{
  "cluster": "",
  "nextToken": "",
  "maxResults": "",
  "launchType": "",
  "schedulingStrategy": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"launchType\": \"\",\n  \"schedulingStrategy\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"launchType\": \"\",\n  \"schedulingStrategy\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"launchType\": \"\",\n  \"schedulingStrategy\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"launchType\": \"\",\n  \"schedulingStrategy\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  nextToken: '',
  maxResults: '',
  launchType: '',
  schedulingStrategy: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    cluster: '',
    nextToken: '',
    maxResults: '',
    launchType: '',
    schedulingStrategy: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","nextToken":"","maxResults":"","launchType":"","schedulingStrategy":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "nextToken": "",\n  "maxResults": "",\n  "launchType": "",\n  "schedulingStrategy": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"launchType\": \"\",\n  \"schedulingStrategy\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  cluster: '',
  nextToken: '',
  maxResults: '',
  launchType: '',
  schedulingStrategy: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    cluster: '',
    nextToken: '',
    maxResults: '',
    launchType: '',
    schedulingStrategy: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  nextToken: '',
  maxResults: '',
  launchType: '',
  schedulingStrategy: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    cluster: '',
    nextToken: '',
    maxResults: '',
    launchType: '',
    schedulingStrategy: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","nextToken":"","maxResults":"","launchType":"","schedulingStrategy":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"nextToken": @"",
                              @"maxResults": @"",
                              @"launchType": @"",
                              @"schedulingStrategy": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"launchType\": \"\",\n  \"schedulingStrategy\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'nextToken' => '',
    'maxResults' => '',
    'launchType' => '',
    'schedulingStrategy' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices', [
  'body' => '{
  "cluster": "",
  "nextToken": "",
  "maxResults": "",
  "launchType": "",
  "schedulingStrategy": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'nextToken' => '',
  'maxResults' => '',
  'launchType' => '',
  'schedulingStrategy' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'nextToken' => '',
  'maxResults' => '',
  'launchType' => '',
  'schedulingStrategy' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "nextToken": "",
  "maxResults": "",
  "launchType": "",
  "schedulingStrategy": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "nextToken": "",
  "maxResults": "",
  "launchType": "",
  "schedulingStrategy": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"launchType\": \"\",\n  \"schedulingStrategy\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices"

payload = {
    "cluster": "",
    "nextToken": "",
    "maxResults": "",
    "launchType": "",
    "schedulingStrategy": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices"

payload <- "{\n  \"cluster\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"launchType\": \"\",\n  \"schedulingStrategy\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"launchType\": \"\",\n  \"schedulingStrategy\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"launchType\": \"\",\n  \"schedulingStrategy\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices";

    let payload = json!({
        "cluster": "",
        "nextToken": "",
        "maxResults": "",
        "launchType": "",
        "schedulingStrategy": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "nextToken": "",
  "maxResults": "",
  "launchType": "",
  "schedulingStrategy": ""
}'

echo '{
  "cluster": "",
  "nextToken": "",
  "maxResults": "",
  "launchType": "",
  "schedulingStrategy": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "nextToken": "",\n  "maxResults": "",\n  "launchType": "",\n  "schedulingStrategy": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "nextToken": "",
  "maxResults": "",
  "launchType": "",
  "schedulingStrategy": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServices")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "serviceArns": [
    "arn:aws:ecs:us-east-1:012345678910:service/my-http-service"
  ]
}

POST ListServicesByNamespace

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace

HEADERS

X-Amz-Target

BODY json

{
  "namespace": "",
  "nextToken": "",
  "maxResults": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"namespace\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace" {:headers {:x-amz-target ""}
                                                                                                                     :content-type :json
                                                                                                                     :form-params {:namespace ""
                                                                                                                                   :nextToken ""
                                                                                                                                   :maxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"namespace\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"namespace\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"namespace\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace"

	payload := strings.NewReader("{\n  \"namespace\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 60

{
  "namespace": "",
  "nextToken": "",
  "maxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"namespace\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"namespace\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"namespace\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"namespace\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  namespace: '',
  nextToken: '',
  maxResults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {namespace: '', nextToken: '', maxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"namespace":"","nextToken":"","maxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "namespace": "",\n  "nextToken": "",\n  "maxResults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"namespace\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({namespace: '', nextToken: '', maxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {namespace: '', nextToken: '', maxResults: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  namespace: '',
  nextToken: '',
  maxResults: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {namespace: '', nextToken: '', maxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"namespace":"","nextToken":"","maxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"namespace": @"",
                              @"nextToken": @"",
                              @"maxResults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"namespace\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'namespace' => '',
    'nextToken' => '',
    'maxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace', [
  'body' => '{
  "namespace": "",
  "nextToken": "",
  "maxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'namespace' => '',
  'nextToken' => '',
  'maxResults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'namespace' => '',
  'nextToken' => '',
  'maxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "namespace": "",
  "nextToken": "",
  "maxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "namespace": "",
  "nextToken": "",
  "maxResults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"namespace\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace"

payload = {
    "namespace": "",
    "nextToken": "",
    "maxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace"

payload <- "{\n  \"namespace\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"namespace\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"namespace\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace";

    let payload = json!({
        "namespace": "",
        "nextToken": "",
        "maxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "namespace": "",
  "nextToken": "",
  "maxResults": ""
}'

echo '{
  "namespace": "",
  "nextToken": "",
  "maxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "namespace": "",\n  "nextToken": "",\n  "maxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "namespace": "",
  "nextToken": "",
  "maxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListServicesByNamespace")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListTagsForResource

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource

HEADERS

X-Amz-Target

BODY json

{
  "resourceArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"resourceArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:resourceArn ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceArn\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"resourceArn\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource"

	payload := strings.NewReader("{\n  \"resourceArn\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "resourceArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceArn\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"resourceArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"resourceArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resourceArn: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {resourceArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"resourceArn":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceArn": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resourceArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({resourceArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {resourceArn: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  resourceArn: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {resourceArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"resourceArn":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"resourceArn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceArn\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'resourceArn' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource', [
  'body' => '{
  "resourceArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceArn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'resourceArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceArn": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceArn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"resourceArn\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource"

payload = { "resourceArn": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource"

payload <- "{\n  \"resourceArn\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"resourceArn\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"resourceArn\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource";

    let payload = json!({"resourceArn": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "resourceArn": ""
}'

echo '{
  "resourceArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceArn": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["resourceArn": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTagsForResource")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "tags": [
    {
      "key": "team",
      "value": "dev"
    }
  ]
}

POST ListTaskDefinitionFamilies

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies

HEADERS

X-Amz-Target

BODY json

{
  "familyPrefix": "",
  "status": "",
  "nextToken": "",
  "maxResults": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies" {:headers {:x-amz-target ""}
                                                                                                                        :content-type :json
                                                                                                                        :form-params {:familyPrefix ""
                                                                                                                                      :status ""
                                                                                                                                      :nextToken ""
                                                                                                                                      :maxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies"

	payload := strings.NewReader("{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 79

{
  "familyPrefix": "",
  "status": "",
  "nextToken": "",
  "maxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  familyPrefix: '',
  status: '',
  nextToken: '',
  maxResults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {familyPrefix: '', status: '', nextToken: '', maxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"familyPrefix":"","status":"","nextToken":"","maxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "familyPrefix": "",\n  "status": "",\n  "nextToken": "",\n  "maxResults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({familyPrefix: '', status: '', nextToken: '', maxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {familyPrefix: '', status: '', nextToken: '', maxResults: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  familyPrefix: '',
  status: '',
  nextToken: '',
  maxResults: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {familyPrefix: '', status: '', nextToken: '', maxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"familyPrefix":"","status":"","nextToken":"","maxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"familyPrefix": @"",
                              @"status": @"",
                              @"nextToken": @"",
                              @"maxResults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'familyPrefix' => '',
    'status' => '',
    'nextToken' => '',
    'maxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies', [
  'body' => '{
  "familyPrefix": "",
  "status": "",
  "nextToken": "",
  "maxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'familyPrefix' => '',
  'status' => '',
  'nextToken' => '',
  'maxResults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'familyPrefix' => '',
  'status' => '',
  'nextToken' => '',
  'maxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "familyPrefix": "",
  "status": "",
  "nextToken": "",
  "maxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "familyPrefix": "",
  "status": "",
  "nextToken": "",
  "maxResults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies"

payload = {
    "familyPrefix": "",
    "status": "",
    "nextToken": "",
    "maxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies"

payload <- "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies";

    let payload = json!({
        "familyPrefix": "",
        "status": "",
        "nextToken": "",
        "maxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "familyPrefix": "",
  "status": "",
  "nextToken": "",
  "maxResults": ""
}'

echo '{
  "familyPrefix": "",
  "status": "",
  "nextToken": "",
  "maxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "familyPrefix": "",\n  "status": "",\n  "nextToken": "",\n  "maxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "familyPrefix": "",
  "status": "",
  "nextToken": "",
  "maxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "families": [
    "hpcc",
    "hpcc-c4-8xlarge"
  ]
}

POST ListTaskDefinitions

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions

HEADERS

X-Amz-Target

BODY json

{
  "familyPrefix": "",
  "status": "",
  "sort": "",
  "nextToken": "",
  "maxResults": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"sort\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:familyPrefix ""
                                                                                                                               :status ""
                                                                                                                               :sort ""
                                                                                                                               :nextToken ""
                                                                                                                               :maxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"sort\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"sort\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"sort\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions"

	payload := strings.NewReader("{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"sort\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 93

{
  "familyPrefix": "",
  "status": "",
  "sort": "",
  "nextToken": "",
  "maxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"sort\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"sort\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"sort\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"sort\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  familyPrefix: '',
  status: '',
  sort: '',
  nextToken: '',
  maxResults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {familyPrefix: '', status: '', sort: '', nextToken: '', maxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"familyPrefix":"","status":"","sort":"","nextToken":"","maxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "familyPrefix": "",\n  "status": "",\n  "sort": "",\n  "nextToken": "",\n  "maxResults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"sort\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({familyPrefix: '', status: '', sort: '', nextToken: '', maxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {familyPrefix: '', status: '', sort: '', nextToken: '', maxResults: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  familyPrefix: '',
  status: '',
  sort: '',
  nextToken: '',
  maxResults: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {familyPrefix: '', status: '', sort: '', nextToken: '', maxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"familyPrefix":"","status":"","sort":"","nextToken":"","maxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"familyPrefix": @"",
                              @"status": @"",
                              @"sort": @"",
                              @"nextToken": @"",
                              @"maxResults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"sort\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'familyPrefix' => '',
    'status' => '',
    'sort' => '',
    'nextToken' => '',
    'maxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions', [
  'body' => '{
  "familyPrefix": "",
  "status": "",
  "sort": "",
  "nextToken": "",
  "maxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'familyPrefix' => '',
  'status' => '',
  'sort' => '',
  'nextToken' => '',
  'maxResults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'familyPrefix' => '',
  'status' => '',
  'sort' => '',
  'nextToken' => '',
  'maxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "familyPrefix": "",
  "status": "",
  "sort": "",
  "nextToken": "",
  "maxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "familyPrefix": "",
  "status": "",
  "sort": "",
  "nextToken": "",
  "maxResults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"sort\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions"

payload = {
    "familyPrefix": "",
    "status": "",
    "sort": "",
    "nextToken": "",
    "maxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions"

payload <- "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"sort\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"sort\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"familyPrefix\": \"\",\n  \"status\": \"\",\n  \"sort\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions";

    let payload = json!({
        "familyPrefix": "",
        "status": "",
        "sort": "",
        "nextToken": "",
        "maxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "familyPrefix": "",
  "status": "",
  "sort": "",
  "nextToken": "",
  "maxResults": ""
}'

echo '{
  "familyPrefix": "",
  "status": "",
  "sort": "",
  "nextToken": "",
  "maxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "familyPrefix": "",\n  "status": "",\n  "sort": "",\n  "nextToken": "",\n  "maxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "familyPrefix": "",
  "status": "",
  "sort": "",
  "nextToken": "",
  "maxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTaskDefinitions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "taskDefinitionArns": [
    "arn:aws:ecs:us-east-1::task-definition/wordpress:3",
    "arn:aws:ecs:us-east-1::task-definition/wordpress:4",
    "arn:aws:ecs:us-east-1::task-definition/wordpress:5",
    "arn:aws:ecs:us-east-1::task-definition/wordpress:6"
  ]
}

POST ListTasks

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "containerInstance": "",
  "family": "",
  "nextToken": "",
  "maxResults": "",
  "startedBy": "",
  "serviceName": "",
  "desiredStatus": "",
  "launchType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"family\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"startedBy\": \"\",\n  \"serviceName\": \"\",\n  \"desiredStatus\": \"\",\n  \"launchType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:cluster ""
                                                                                                                     :containerInstance ""
                                                                                                                     :family ""
                                                                                                                     :nextToken ""
                                                                                                                     :maxResults ""
                                                                                                                     :startedBy ""
                                                                                                                     :serviceName ""
                                                                                                                     :desiredStatus ""
                                                                                                                     :launchType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"family\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"startedBy\": \"\",\n  \"serviceName\": \"\",\n  \"desiredStatus\": \"\",\n  \"launchType\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"family\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"startedBy\": \"\",\n  \"serviceName\": \"\",\n  \"desiredStatus\": \"\",\n  \"launchType\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"family\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"startedBy\": \"\",\n  \"serviceName\": \"\",\n  \"desiredStatus\": \"\",\n  \"launchType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"family\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"startedBy\": \"\",\n  \"serviceName\": \"\",\n  \"desiredStatus\": \"\",\n  \"launchType\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 184

{
  "cluster": "",
  "containerInstance": "",
  "family": "",
  "nextToken": "",
  "maxResults": "",
  "startedBy": "",
  "serviceName": "",
  "desiredStatus": "",
  "launchType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"family\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"startedBy\": \"\",\n  \"serviceName\": \"\",\n  \"desiredStatus\": \"\",\n  \"launchType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"family\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"startedBy\": \"\",\n  \"serviceName\": \"\",\n  \"desiredStatus\": \"\",\n  \"launchType\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"family\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"startedBy\": \"\",\n  \"serviceName\": \"\",\n  \"desiredStatus\": \"\",\n  \"launchType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"family\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"startedBy\": \"\",\n  \"serviceName\": \"\",\n  \"desiredStatus\": \"\",\n  \"launchType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  containerInstance: '',
  family: '',
  nextToken: '',
  maxResults: '',
  startedBy: '',
  serviceName: '',
  desiredStatus: '',
  launchType: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    cluster: '',
    containerInstance: '',
    family: '',
    nextToken: '',
    maxResults: '',
    startedBy: '',
    serviceName: '',
    desiredStatus: '',
    launchType: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","containerInstance":"","family":"","nextToken":"","maxResults":"","startedBy":"","serviceName":"","desiredStatus":"","launchType":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "containerInstance": "",\n  "family": "",\n  "nextToken": "",\n  "maxResults": "",\n  "startedBy": "",\n  "serviceName": "",\n  "desiredStatus": "",\n  "launchType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"family\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"startedBy\": \"\",\n  \"serviceName\": \"\",\n  \"desiredStatus\": \"\",\n  \"launchType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  cluster: '',
  containerInstance: '',
  family: '',
  nextToken: '',
  maxResults: '',
  startedBy: '',
  serviceName: '',
  desiredStatus: '',
  launchType: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    cluster: '',
    containerInstance: '',
    family: '',
    nextToken: '',
    maxResults: '',
    startedBy: '',
    serviceName: '',
    desiredStatus: '',
    launchType: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  containerInstance: '',
  family: '',
  nextToken: '',
  maxResults: '',
  startedBy: '',
  serviceName: '',
  desiredStatus: '',
  launchType: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    cluster: '',
    containerInstance: '',
    family: '',
    nextToken: '',
    maxResults: '',
    startedBy: '',
    serviceName: '',
    desiredStatus: '',
    launchType: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","containerInstance":"","family":"","nextToken":"","maxResults":"","startedBy":"","serviceName":"","desiredStatus":"","launchType":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"containerInstance": @"",
                              @"family": @"",
                              @"nextToken": @"",
                              @"maxResults": @"",
                              @"startedBy": @"",
                              @"serviceName": @"",
                              @"desiredStatus": @"",
                              @"launchType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"family\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"startedBy\": \"\",\n  \"serviceName\": \"\",\n  \"desiredStatus\": \"\",\n  \"launchType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'containerInstance' => '',
    'family' => '',
    'nextToken' => '',
    'maxResults' => '',
    'startedBy' => '',
    'serviceName' => '',
    'desiredStatus' => '',
    'launchType' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks', [
  'body' => '{
  "cluster": "",
  "containerInstance": "",
  "family": "",
  "nextToken": "",
  "maxResults": "",
  "startedBy": "",
  "serviceName": "",
  "desiredStatus": "",
  "launchType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'containerInstance' => '',
  'family' => '',
  'nextToken' => '',
  'maxResults' => '',
  'startedBy' => '',
  'serviceName' => '',
  'desiredStatus' => '',
  'launchType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'containerInstance' => '',
  'family' => '',
  'nextToken' => '',
  'maxResults' => '',
  'startedBy' => '',
  'serviceName' => '',
  'desiredStatus' => '',
  'launchType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "containerInstance": "",
  "family": "",
  "nextToken": "",
  "maxResults": "",
  "startedBy": "",
  "serviceName": "",
  "desiredStatus": "",
  "launchType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "containerInstance": "",
  "family": "",
  "nextToken": "",
  "maxResults": "",
  "startedBy": "",
  "serviceName": "",
  "desiredStatus": "",
  "launchType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"family\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"startedBy\": \"\",\n  \"serviceName\": \"\",\n  \"desiredStatus\": \"\",\n  \"launchType\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks"

payload = {
    "cluster": "",
    "containerInstance": "",
    "family": "",
    "nextToken": "",
    "maxResults": "",
    "startedBy": "",
    "serviceName": "",
    "desiredStatus": "",
    "launchType": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks"

payload <- "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"family\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"startedBy\": \"\",\n  \"serviceName\": \"\",\n  \"desiredStatus\": \"\",\n  \"launchType\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"family\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"startedBy\": \"\",\n  \"serviceName\": \"\",\n  \"desiredStatus\": \"\",\n  \"launchType\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\",\n  \"family\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"startedBy\": \"\",\n  \"serviceName\": \"\",\n  \"desiredStatus\": \"\",\n  \"launchType\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks";

    let payload = json!({
        "cluster": "",
        "containerInstance": "",
        "family": "",
        "nextToken": "",
        "maxResults": "",
        "startedBy": "",
        "serviceName": "",
        "desiredStatus": "",
        "launchType": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "containerInstance": "",
  "family": "",
  "nextToken": "",
  "maxResults": "",
  "startedBy": "",
  "serviceName": "",
  "desiredStatus": "",
  "launchType": ""
}'

echo '{
  "cluster": "",
  "containerInstance": "",
  "family": "",
  "nextToken": "",
  "maxResults": "",
  "startedBy": "",
  "serviceName": "",
  "desiredStatus": "",
  "launchType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "containerInstance": "",\n  "family": "",\n  "nextToken": "",\n  "maxResults": "",\n  "startedBy": "",\n  "serviceName": "",\n  "desiredStatus": "",\n  "launchType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "containerInstance": "",
  "family": "",
  "nextToken": "",
  "maxResults": "",
  "startedBy": "",
  "serviceName": "",
  "desiredStatus": "",
  "launchType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.ListTasks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "taskArns": [
    "arn:aws:ecs:us-east-1:012345678910:task/0cc43cdb-3bee-4407-9c26-c0e6ea5bee84"
  ]
}

POST PutAccountSetting

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting

HEADERS

X-Amz-Target

BODY json

{
  "name": "",
  "value": "",
  "principalArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:name ""
                                                                                                                             :value ""
                                                                                                                             :principalArn ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 53

{
  "name": "",
  "value": "",
  "principalArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  value: '',
  principalArn: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: '', value: '', principalArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","value":"","principalArn":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "value": "",\n  "principalArn": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({name: '', value: '', principalArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {name: '', value: '', principalArn: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: '',
  value: '',
  principalArn: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: '', value: '', principalArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","value":"","principalArn":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"",
                              @"value": @"",
                              @"principalArn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'value' => '',
    'principalArn' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting', [
  'body' => '{
  "name": "",
  "value": "",
  "principalArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'value' => '',
  'principalArn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => '',
  'value' => '',
  'principalArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "value": "",
  "principalArn": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "value": "",
  "principalArn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting"

payload = {
    "name": "",
    "value": "",
    "principalArn": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting"

payload <- "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"name\": \"\",\n  \"value\": \"\",\n  \"principalArn\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting";

    let payload = json!({
        "name": "",
        "value": "",
        "principalArn": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": "",
  "value": "",
  "principalArn": ""
}'

echo '{
  "name": "",
  "value": "",
  "principalArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "value": "",\n  "principalArn": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "name": "",
  "value": "",
  "principalArn": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSetting")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "setting": {
    "name": "containerInstanceLongArnFormat",
    "value": "enabled",
    "principalArn": "arn:aws:iam:::user/principalName"
  }
}

POST PutAccountSettingDefault

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault

HEADERS

X-Amz-Target

BODY json

{
  "name": "",
  "value": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\",\n  \"value\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault" {:headers {:x-amz-target ""}
                                                                                                                      :content-type :json
                                                                                                                      :form-params {:name ""
                                                                                                                                    :value ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"value\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"name\": \"\",\n  \"value\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"value\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"value\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 31

{
  "name": "",
  "value": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"value\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"value\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"value\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"value\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  value: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: '', value: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","value":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "value": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"value\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({name: '', value: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {name: '', value: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: '',
  value: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: '', value: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","value":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"",
                              @"value": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"value\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'value' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault', [
  'body' => '{
  "name": "",
  "value": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'value' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => '',
  'value' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "value": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "value": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\",\n  \"value\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault"

payload = {
    "name": "",
    "value": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault"

payload <- "{\n  \"name\": \"\",\n  \"value\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"value\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"name\": \"\",\n  \"value\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault";

    let payload = json!({
        "name": "",
        "value": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": "",
  "value": ""
}'

echo '{
  "name": "",
  "value": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "value": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "name": "",
  "value": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "setting": {
    "name": "serviceLongArnFormat",
    "value": "enabled",
    "principalArn": "arn:aws:iam:::root"
  }
}

POST PutAttributes

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "attributes": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:cluster ""
                                                                                                                         :attributes ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 39

{
  "cluster": "",
  "attributes": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  attributes: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', attributes: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","attributes":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "attributes": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', attributes: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', attributes: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  attributes: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', attributes: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","attributes":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"attributes": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'attributes' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes', [
  'body' => '{
  "cluster": "",
  "attributes": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'attributes' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'attributes' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "attributes": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "attributes": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes"

payload = {
    "cluster": "",
    "attributes": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes"

payload <- "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"attributes\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes";

    let payload = json!({
        "cluster": "",
        "attributes": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "attributes": ""
}'

echo '{
  "cluster": "",
  "attributes": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "attributes": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "attributes": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutAttributes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST PutClusterCapacityProviders

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "capacityProviders": "",
  "defaultCapacityProviderStrategy": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders" {:headers {:x-amz-target ""}
                                                                                                                         :content-type :json
                                                                                                                         :form-params {:cluster ""
                                                                                                                                       :capacityProviders ""
                                                                                                                                       :defaultCapacityProviderStrategy ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 87

{
  "cluster": "",
  "capacityProviders": "",
  "defaultCapacityProviderStrategy": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  capacityProviders: '',
  defaultCapacityProviderStrategy: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', capacityProviders: '', defaultCapacityProviderStrategy: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","capacityProviders":"","defaultCapacityProviderStrategy":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "capacityProviders": "",\n  "defaultCapacityProviderStrategy": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', capacityProviders: '', defaultCapacityProviderStrategy: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', capacityProviders: '', defaultCapacityProviderStrategy: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  capacityProviders: '',
  defaultCapacityProviderStrategy: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', capacityProviders: '', defaultCapacityProviderStrategy: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","capacityProviders":"","defaultCapacityProviderStrategy":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"capacityProviders": @"",
                              @"defaultCapacityProviderStrategy": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'capacityProviders' => '',
    'defaultCapacityProviderStrategy' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders', [
  'body' => '{
  "cluster": "",
  "capacityProviders": "",
  "defaultCapacityProviderStrategy": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'capacityProviders' => '',
  'defaultCapacityProviderStrategy' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'capacityProviders' => '',
  'defaultCapacityProviderStrategy' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "capacityProviders": "",
  "defaultCapacityProviderStrategy": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "capacityProviders": "",
  "defaultCapacityProviderStrategy": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders"

payload = {
    "cluster": "",
    "capacityProviders": "",
    "defaultCapacityProviderStrategy": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders"

payload <- "{\n  \"cluster\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"capacityProviders\": \"\",\n  \"defaultCapacityProviderStrategy\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders";

    let payload = json!({
        "cluster": "",
        "capacityProviders": "",
        "defaultCapacityProviderStrategy": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "capacityProviders": "",
  "defaultCapacityProviderStrategy": ""
}'

echo '{
  "cluster": "",
  "capacityProviders": "",
  "defaultCapacityProviderStrategy": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "capacityProviders": "",\n  "defaultCapacityProviderStrategy": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "capacityProviders": "",
  "defaultCapacityProviderStrategy": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST RegisterContainerInstance

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "instanceIdentityDocument": "",
  "instanceIdentityDocumentSignature": "",
  "totalResources": "",
  "versionInfo": "",
  "containerInstanceArn": "",
  "attributes": "",
  "platformDevices": "",
  "tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"instanceIdentityDocument\": \"\",\n  \"instanceIdentityDocumentSignature\": \"\",\n  \"totalResources\": \"\",\n  \"versionInfo\": \"\",\n  \"containerInstanceArn\": \"\",\n  \"attributes\": \"\",\n  \"platformDevices\": \"\",\n  \"tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance" {:headers {:x-amz-target ""}
                                                                                                                       :content-type :json
                                                                                                                       :form-params {:cluster ""
                                                                                                                                     :instanceIdentityDocument ""
                                                                                                                                     :instanceIdentityDocumentSignature ""
                                                                                                                                     :totalResources ""
                                                                                                                                     :versionInfo ""
                                                                                                                                     :containerInstanceArn ""
                                                                                                                                     :attributes ""
                                                                                                                                     :platformDevices ""
                                                                                                                                     :tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"instanceIdentityDocument\": \"\",\n  \"instanceIdentityDocumentSignature\": \"\",\n  \"totalResources\": \"\",\n  \"versionInfo\": \"\",\n  \"containerInstanceArn\": \"\",\n  \"attributes\": \"\",\n  \"platformDevices\": \"\",\n  \"tags\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"instanceIdentityDocument\": \"\",\n  \"instanceIdentityDocumentSignature\": \"\",\n  \"totalResources\": \"\",\n  \"versionInfo\": \"\",\n  \"containerInstanceArn\": \"\",\n  \"attributes\": \"\",\n  \"platformDevices\": \"\",\n  \"tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"instanceIdentityDocument\": \"\",\n  \"instanceIdentityDocumentSignature\": \"\",\n  \"totalResources\": \"\",\n  \"versionInfo\": \"\",\n  \"containerInstanceArn\": \"\",\n  \"attributes\": \"\",\n  \"platformDevices\": \"\",\n  \"tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"instanceIdentityDocument\": \"\",\n  \"instanceIdentityDocumentSignature\": \"\",\n  \"totalResources\": \"\",\n  \"versionInfo\": \"\",\n  \"containerInstanceArn\": \"\",\n  \"attributes\": \"\",\n  \"platformDevices\": \"\",\n  \"tags\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 230

{
  "cluster": "",
  "instanceIdentityDocument": "",
  "instanceIdentityDocumentSignature": "",
  "totalResources": "",
  "versionInfo": "",
  "containerInstanceArn": "",
  "attributes": "",
  "platformDevices": "",
  "tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"instanceIdentityDocument\": \"\",\n  \"instanceIdentityDocumentSignature\": \"\",\n  \"totalResources\": \"\",\n  \"versionInfo\": \"\",\n  \"containerInstanceArn\": \"\",\n  \"attributes\": \"\",\n  \"platformDevices\": \"\",\n  \"tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"instanceIdentityDocument\": \"\",\n  \"instanceIdentityDocumentSignature\": \"\",\n  \"totalResources\": \"\",\n  \"versionInfo\": \"\",\n  \"containerInstanceArn\": \"\",\n  \"attributes\": \"\",\n  \"platformDevices\": \"\",\n  \"tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"instanceIdentityDocument\": \"\",\n  \"instanceIdentityDocumentSignature\": \"\",\n  \"totalResources\": \"\",\n  \"versionInfo\": \"\",\n  \"containerInstanceArn\": \"\",\n  \"attributes\": \"\",\n  \"platformDevices\": \"\",\n  \"tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"instanceIdentityDocument\": \"\",\n  \"instanceIdentityDocumentSignature\": \"\",\n  \"totalResources\": \"\",\n  \"versionInfo\": \"\",\n  \"containerInstanceArn\": \"\",\n  \"attributes\": \"\",\n  \"platformDevices\": \"\",\n  \"tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  instanceIdentityDocument: '',
  instanceIdentityDocumentSignature: '',
  totalResources: '',
  versionInfo: '',
  containerInstanceArn: '',
  attributes: '',
  platformDevices: '',
  tags: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    cluster: '',
    instanceIdentityDocument: '',
    instanceIdentityDocumentSignature: '',
    totalResources: '',
    versionInfo: '',
    containerInstanceArn: '',
    attributes: '',
    platformDevices: '',
    tags: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","instanceIdentityDocument":"","instanceIdentityDocumentSignature":"","totalResources":"","versionInfo":"","containerInstanceArn":"","attributes":"","platformDevices":"","tags":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "instanceIdentityDocument": "",\n  "instanceIdentityDocumentSignature": "",\n  "totalResources": "",\n  "versionInfo": "",\n  "containerInstanceArn": "",\n  "attributes": "",\n  "platformDevices": "",\n  "tags": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"instanceIdentityDocument\": \"\",\n  \"instanceIdentityDocumentSignature\": \"\",\n  \"totalResources\": \"\",\n  \"versionInfo\": \"\",\n  \"containerInstanceArn\": \"\",\n  \"attributes\": \"\",\n  \"platformDevices\": \"\",\n  \"tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  cluster: '',
  instanceIdentityDocument: '',
  instanceIdentityDocumentSignature: '',
  totalResources: '',
  versionInfo: '',
  containerInstanceArn: '',
  attributes: '',
  platformDevices: '',
  tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    cluster: '',
    instanceIdentityDocument: '',
    instanceIdentityDocumentSignature: '',
    totalResources: '',
    versionInfo: '',
    containerInstanceArn: '',
    attributes: '',
    platformDevices: '',
    tags: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  instanceIdentityDocument: '',
  instanceIdentityDocumentSignature: '',
  totalResources: '',
  versionInfo: '',
  containerInstanceArn: '',
  attributes: '',
  platformDevices: '',
  tags: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    cluster: '',
    instanceIdentityDocument: '',
    instanceIdentityDocumentSignature: '',
    totalResources: '',
    versionInfo: '',
    containerInstanceArn: '',
    attributes: '',
    platformDevices: '',
    tags: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","instanceIdentityDocument":"","instanceIdentityDocumentSignature":"","totalResources":"","versionInfo":"","containerInstanceArn":"","attributes":"","platformDevices":"","tags":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"instanceIdentityDocument": @"",
                              @"instanceIdentityDocumentSignature": @"",
                              @"totalResources": @"",
                              @"versionInfo": @"",
                              @"containerInstanceArn": @"",
                              @"attributes": @"",
                              @"platformDevices": @"",
                              @"tags": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"instanceIdentityDocument\": \"\",\n  \"instanceIdentityDocumentSignature\": \"\",\n  \"totalResources\": \"\",\n  \"versionInfo\": \"\",\n  \"containerInstanceArn\": \"\",\n  \"attributes\": \"\",\n  \"platformDevices\": \"\",\n  \"tags\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'instanceIdentityDocument' => '',
    'instanceIdentityDocumentSignature' => '',
    'totalResources' => '',
    'versionInfo' => '',
    'containerInstanceArn' => '',
    'attributes' => '',
    'platformDevices' => '',
    'tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance', [
  'body' => '{
  "cluster": "",
  "instanceIdentityDocument": "",
  "instanceIdentityDocumentSignature": "",
  "totalResources": "",
  "versionInfo": "",
  "containerInstanceArn": "",
  "attributes": "",
  "platformDevices": "",
  "tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'instanceIdentityDocument' => '',
  'instanceIdentityDocumentSignature' => '',
  'totalResources' => '',
  'versionInfo' => '',
  'containerInstanceArn' => '',
  'attributes' => '',
  'platformDevices' => '',
  'tags' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'instanceIdentityDocument' => '',
  'instanceIdentityDocumentSignature' => '',
  'totalResources' => '',
  'versionInfo' => '',
  'containerInstanceArn' => '',
  'attributes' => '',
  'platformDevices' => '',
  'tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "instanceIdentityDocument": "",
  "instanceIdentityDocumentSignature": "",
  "totalResources": "",
  "versionInfo": "",
  "containerInstanceArn": "",
  "attributes": "",
  "platformDevices": "",
  "tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "instanceIdentityDocument": "",
  "instanceIdentityDocumentSignature": "",
  "totalResources": "",
  "versionInfo": "",
  "containerInstanceArn": "",
  "attributes": "",
  "platformDevices": "",
  "tags": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"instanceIdentityDocument\": \"\",\n  \"instanceIdentityDocumentSignature\": \"\",\n  \"totalResources\": \"\",\n  \"versionInfo\": \"\",\n  \"containerInstanceArn\": \"\",\n  \"attributes\": \"\",\n  \"platformDevices\": \"\",\n  \"tags\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance"

payload = {
    "cluster": "",
    "instanceIdentityDocument": "",
    "instanceIdentityDocumentSignature": "",
    "totalResources": "",
    "versionInfo": "",
    "containerInstanceArn": "",
    "attributes": "",
    "platformDevices": "",
    "tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance"

payload <- "{\n  \"cluster\": \"\",\n  \"instanceIdentityDocument\": \"\",\n  \"instanceIdentityDocumentSignature\": \"\",\n  \"totalResources\": \"\",\n  \"versionInfo\": \"\",\n  \"containerInstanceArn\": \"\",\n  \"attributes\": \"\",\n  \"platformDevices\": \"\",\n  \"tags\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"instanceIdentityDocument\": \"\",\n  \"instanceIdentityDocumentSignature\": \"\",\n  \"totalResources\": \"\",\n  \"versionInfo\": \"\",\n  \"containerInstanceArn\": \"\",\n  \"attributes\": \"\",\n  \"platformDevices\": \"\",\n  \"tags\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"instanceIdentityDocument\": \"\",\n  \"instanceIdentityDocumentSignature\": \"\",\n  \"totalResources\": \"\",\n  \"versionInfo\": \"\",\n  \"containerInstanceArn\": \"\",\n  \"attributes\": \"\",\n  \"platformDevices\": \"\",\n  \"tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance";

    let payload = json!({
        "cluster": "",
        "instanceIdentityDocument": "",
        "instanceIdentityDocumentSignature": "",
        "totalResources": "",
        "versionInfo": "",
        "containerInstanceArn": "",
        "attributes": "",
        "platformDevices": "",
        "tags": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "instanceIdentityDocument": "",
  "instanceIdentityDocumentSignature": "",
  "totalResources": "",
  "versionInfo": "",
  "containerInstanceArn": "",
  "attributes": "",
  "platformDevices": "",
  "tags": ""
}'

echo '{
  "cluster": "",
  "instanceIdentityDocument": "",
  "instanceIdentityDocumentSignature": "",
  "totalResources": "",
  "versionInfo": "",
  "containerInstanceArn": "",
  "attributes": "",
  "platformDevices": "",
  "tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "instanceIdentityDocument": "",\n  "instanceIdentityDocumentSignature": "",\n  "totalResources": "",\n  "versionInfo": "",\n  "containerInstanceArn": "",\n  "attributes": "",\n  "platformDevices": "",\n  "tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "instanceIdentityDocument": "",
  "instanceIdentityDocumentSignature": "",
  "totalResources": "",
  "versionInfo": "",
  "containerInstanceArn": "",
  "attributes": "",
  "platformDevices": "",
  "tags": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterContainerInstance")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST RegisterTaskDefinition

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition

HEADERS

X-Amz-Target

BODY json

{
  "family": "",
  "taskRoleArn": "",
  "executionRoleArn": "",
  "networkMode": "",
  "containerDefinitions": "",
  "volumes": "",
  "placementConstraints": "",
  "requiresCompatibilities": "",
  "cpu": "",
  "memory": "",
  "tags": "",
  "pidMode": "",
  "ipcMode": "",
  "proxyConfiguration": "",
  "inferenceAccelerators": "",
  "ephemeralStorage": "",
  "runtimePlatform": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"family\": \"\",\n  \"taskRoleArn\": \"\",\n  \"executionRoleArn\": \"\",\n  \"networkMode\": \"\",\n  \"containerDefinitions\": \"\",\n  \"volumes\": \"\",\n  \"placementConstraints\": \"\",\n  \"requiresCompatibilities\": \"\",\n  \"cpu\": \"\",\n  \"memory\": \"\",\n  \"tags\": \"\",\n  \"pidMode\": \"\",\n  \"ipcMode\": \"\",\n  \"proxyConfiguration\": \"\",\n  \"inferenceAccelerators\": \"\",\n  \"ephemeralStorage\": \"\",\n  \"runtimePlatform\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:family ""
                                                                                                                                  :taskRoleArn ""
                                                                                                                                  :executionRoleArn ""
                                                                                                                                  :networkMode ""
                                                                                                                                  :containerDefinitions ""
                                                                                                                                  :volumes ""
                                                                                                                                  :placementConstraints ""
                                                                                                                                  :requiresCompatibilities ""
                                                                                                                                  :cpu ""
                                                                                                                                  :memory ""
                                                                                                                                  :tags ""
                                                                                                                                  :pidMode ""
                                                                                                                                  :ipcMode ""
                                                                                                                                  :proxyConfiguration ""
                                                                                                                                  :inferenceAccelerators ""
                                                                                                                                  :ephemeralStorage ""
                                                                                                                                  :runtimePlatform ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"family\": \"\",\n  \"taskRoleArn\": \"\",\n  \"executionRoleArn\": \"\",\n  \"networkMode\": \"\",\n  \"containerDefinitions\": \"\",\n  \"volumes\": \"\",\n  \"placementConstraints\": \"\",\n  \"requiresCompatibilities\": \"\",\n  \"cpu\": \"\",\n  \"memory\": \"\",\n  \"tags\": \"\",\n  \"pidMode\": \"\",\n  \"ipcMode\": \"\",\n  \"proxyConfiguration\": \"\",\n  \"inferenceAccelerators\": \"\",\n  \"ephemeralStorage\": \"\",\n  \"runtimePlatform\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"family\": \"\",\n  \"taskRoleArn\": \"\",\n  \"executionRoleArn\": \"\",\n  \"networkMode\": \"\",\n  \"containerDefinitions\": \"\",\n  \"volumes\": \"\",\n  \"placementConstraints\": \"\",\n  \"requiresCompatibilities\": \"\",\n  \"cpu\": \"\",\n  \"memory\": \"\",\n  \"tags\": \"\",\n  \"pidMode\": \"\",\n  \"ipcMode\": \"\",\n  \"proxyConfiguration\": \"\",\n  \"inferenceAccelerators\": \"\",\n  \"ephemeralStorage\": \"\",\n  \"runtimePlatform\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"family\": \"\",\n  \"taskRoleArn\": \"\",\n  \"executionRoleArn\": \"\",\n  \"networkMode\": \"\",\n  \"containerDefinitions\": \"\",\n  \"volumes\": \"\",\n  \"placementConstraints\": \"\",\n  \"requiresCompatibilities\": \"\",\n  \"cpu\": \"\",\n  \"memory\": \"\",\n  \"tags\": \"\",\n  \"pidMode\": \"\",\n  \"ipcMode\": \"\",\n  \"proxyConfiguration\": \"\",\n  \"inferenceAccelerators\": \"\",\n  \"ephemeralStorage\": \"\",\n  \"runtimePlatform\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition"

	payload := strings.NewReader("{\n  \"family\": \"\",\n  \"taskRoleArn\": \"\",\n  \"executionRoleArn\": \"\",\n  \"networkMode\": \"\",\n  \"containerDefinitions\": \"\",\n  \"volumes\": \"\",\n  \"placementConstraints\": \"\",\n  \"requiresCompatibilities\": \"\",\n  \"cpu\": \"\",\n  \"memory\": \"\",\n  \"tags\": \"\",\n  \"pidMode\": \"\",\n  \"ipcMode\": \"\",\n  \"proxyConfiguration\": \"\",\n  \"inferenceAccelerators\": \"\",\n  \"ephemeralStorage\": \"\",\n  \"runtimePlatform\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 383

{
  "family": "",
  "taskRoleArn": "",
  "executionRoleArn": "",
  "networkMode": "",
  "containerDefinitions": "",
  "volumes": "",
  "placementConstraints": "",
  "requiresCompatibilities": "",
  "cpu": "",
  "memory": "",
  "tags": "",
  "pidMode": "",
  "ipcMode": "",
  "proxyConfiguration": "",
  "inferenceAccelerators": "",
  "ephemeralStorage": "",
  "runtimePlatform": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"family\": \"\",\n  \"taskRoleArn\": \"\",\n  \"executionRoleArn\": \"\",\n  \"networkMode\": \"\",\n  \"containerDefinitions\": \"\",\n  \"volumes\": \"\",\n  \"placementConstraints\": \"\",\n  \"requiresCompatibilities\": \"\",\n  \"cpu\": \"\",\n  \"memory\": \"\",\n  \"tags\": \"\",\n  \"pidMode\": \"\",\n  \"ipcMode\": \"\",\n  \"proxyConfiguration\": \"\",\n  \"inferenceAccelerators\": \"\",\n  \"ephemeralStorage\": \"\",\n  \"runtimePlatform\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"family\": \"\",\n  \"taskRoleArn\": \"\",\n  \"executionRoleArn\": \"\",\n  \"networkMode\": \"\",\n  \"containerDefinitions\": \"\",\n  \"volumes\": \"\",\n  \"placementConstraints\": \"\",\n  \"requiresCompatibilities\": \"\",\n  \"cpu\": \"\",\n  \"memory\": \"\",\n  \"tags\": \"\",\n  \"pidMode\": \"\",\n  \"ipcMode\": \"\",\n  \"proxyConfiguration\": \"\",\n  \"inferenceAccelerators\": \"\",\n  \"ephemeralStorage\": \"\",\n  \"runtimePlatform\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"family\": \"\",\n  \"taskRoleArn\": \"\",\n  \"executionRoleArn\": \"\",\n  \"networkMode\": \"\",\n  \"containerDefinitions\": \"\",\n  \"volumes\": \"\",\n  \"placementConstraints\": \"\",\n  \"requiresCompatibilities\": \"\",\n  \"cpu\": \"\",\n  \"memory\": \"\",\n  \"tags\": \"\",\n  \"pidMode\": \"\",\n  \"ipcMode\": \"\",\n  \"proxyConfiguration\": \"\",\n  \"inferenceAccelerators\": \"\",\n  \"ephemeralStorage\": \"\",\n  \"runtimePlatform\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"family\": \"\",\n  \"taskRoleArn\": \"\",\n  \"executionRoleArn\": \"\",\n  \"networkMode\": \"\",\n  \"containerDefinitions\": \"\",\n  \"volumes\": \"\",\n  \"placementConstraints\": \"\",\n  \"requiresCompatibilities\": \"\",\n  \"cpu\": \"\",\n  \"memory\": \"\",\n  \"tags\": \"\",\n  \"pidMode\": \"\",\n  \"ipcMode\": \"\",\n  \"proxyConfiguration\": \"\",\n  \"inferenceAccelerators\": \"\",\n  \"ephemeralStorage\": \"\",\n  \"runtimePlatform\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  family: '',
  taskRoleArn: '',
  executionRoleArn: '',
  networkMode: '',
  containerDefinitions: '',
  volumes: '',
  placementConstraints: '',
  requiresCompatibilities: '',
  cpu: '',
  memory: '',
  tags: '',
  pidMode: '',
  ipcMode: '',
  proxyConfiguration: '',
  inferenceAccelerators: '',
  ephemeralStorage: '',
  runtimePlatform: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    family: '',
    taskRoleArn: '',
    executionRoleArn: '',
    networkMode: '',
    containerDefinitions: '',
    volumes: '',
    placementConstraints: '',
    requiresCompatibilities: '',
    cpu: '',
    memory: '',
    tags: '',
    pidMode: '',
    ipcMode: '',
    proxyConfiguration: '',
    inferenceAccelerators: '',
    ephemeralStorage: '',
    runtimePlatform: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"family":"","taskRoleArn":"","executionRoleArn":"","networkMode":"","containerDefinitions":"","volumes":"","placementConstraints":"","requiresCompatibilities":"","cpu":"","memory":"","tags":"","pidMode":"","ipcMode":"","proxyConfiguration":"","inferenceAccelerators":"","ephemeralStorage":"","runtimePlatform":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "family": "",\n  "taskRoleArn": "",\n  "executionRoleArn": "",\n  "networkMode": "",\n  "containerDefinitions": "",\n  "volumes": "",\n  "placementConstraints": "",\n  "requiresCompatibilities": "",\n  "cpu": "",\n  "memory": "",\n  "tags": "",\n  "pidMode": "",\n  "ipcMode": "",\n  "proxyConfiguration": "",\n  "inferenceAccelerators": "",\n  "ephemeralStorage": "",\n  "runtimePlatform": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"family\": \"\",\n  \"taskRoleArn\": \"\",\n  \"executionRoleArn\": \"\",\n  \"networkMode\": \"\",\n  \"containerDefinitions\": \"\",\n  \"volumes\": \"\",\n  \"placementConstraints\": \"\",\n  \"requiresCompatibilities\": \"\",\n  \"cpu\": \"\",\n  \"memory\": \"\",\n  \"tags\": \"\",\n  \"pidMode\": \"\",\n  \"ipcMode\": \"\",\n  \"proxyConfiguration\": \"\",\n  \"inferenceAccelerators\": \"\",\n  \"ephemeralStorage\": \"\",\n  \"runtimePlatform\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  family: '',
  taskRoleArn: '',
  executionRoleArn: '',
  networkMode: '',
  containerDefinitions: '',
  volumes: '',
  placementConstraints: '',
  requiresCompatibilities: '',
  cpu: '',
  memory: '',
  tags: '',
  pidMode: '',
  ipcMode: '',
  proxyConfiguration: '',
  inferenceAccelerators: '',
  ephemeralStorage: '',
  runtimePlatform: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    family: '',
    taskRoleArn: '',
    executionRoleArn: '',
    networkMode: '',
    containerDefinitions: '',
    volumes: '',
    placementConstraints: '',
    requiresCompatibilities: '',
    cpu: '',
    memory: '',
    tags: '',
    pidMode: '',
    ipcMode: '',
    proxyConfiguration: '',
    inferenceAccelerators: '',
    ephemeralStorage: '',
    runtimePlatform: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  family: '',
  taskRoleArn: '',
  executionRoleArn: '',
  networkMode: '',
  containerDefinitions: '',
  volumes: '',
  placementConstraints: '',
  requiresCompatibilities: '',
  cpu: '',
  memory: '',
  tags: '',
  pidMode: '',
  ipcMode: '',
  proxyConfiguration: '',
  inferenceAccelerators: '',
  ephemeralStorage: '',
  runtimePlatform: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    family: '',
    taskRoleArn: '',
    executionRoleArn: '',
    networkMode: '',
    containerDefinitions: '',
    volumes: '',
    placementConstraints: '',
    requiresCompatibilities: '',
    cpu: '',
    memory: '',
    tags: '',
    pidMode: '',
    ipcMode: '',
    proxyConfiguration: '',
    inferenceAccelerators: '',
    ephemeralStorage: '',
    runtimePlatform: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"family":"","taskRoleArn":"","executionRoleArn":"","networkMode":"","containerDefinitions":"","volumes":"","placementConstraints":"","requiresCompatibilities":"","cpu":"","memory":"","tags":"","pidMode":"","ipcMode":"","proxyConfiguration":"","inferenceAccelerators":"","ephemeralStorage":"","runtimePlatform":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"family": @"",
                              @"taskRoleArn": @"",
                              @"executionRoleArn": @"",
                              @"networkMode": @"",
                              @"containerDefinitions": @"",
                              @"volumes": @"",
                              @"placementConstraints": @"",
                              @"requiresCompatibilities": @"",
                              @"cpu": @"",
                              @"memory": @"",
                              @"tags": @"",
                              @"pidMode": @"",
                              @"ipcMode": @"",
                              @"proxyConfiguration": @"",
                              @"inferenceAccelerators": @"",
                              @"ephemeralStorage": @"",
                              @"runtimePlatform": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"family\": \"\",\n  \"taskRoleArn\": \"\",\n  \"executionRoleArn\": \"\",\n  \"networkMode\": \"\",\n  \"containerDefinitions\": \"\",\n  \"volumes\": \"\",\n  \"placementConstraints\": \"\",\n  \"requiresCompatibilities\": \"\",\n  \"cpu\": \"\",\n  \"memory\": \"\",\n  \"tags\": \"\",\n  \"pidMode\": \"\",\n  \"ipcMode\": \"\",\n  \"proxyConfiguration\": \"\",\n  \"inferenceAccelerators\": \"\",\n  \"ephemeralStorage\": \"\",\n  \"runtimePlatform\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'family' => '',
    'taskRoleArn' => '',
    'executionRoleArn' => '',
    'networkMode' => '',
    'containerDefinitions' => '',
    'volumes' => '',
    'placementConstraints' => '',
    'requiresCompatibilities' => '',
    'cpu' => '',
    'memory' => '',
    'tags' => '',
    'pidMode' => '',
    'ipcMode' => '',
    'proxyConfiguration' => '',
    'inferenceAccelerators' => '',
    'ephemeralStorage' => '',
    'runtimePlatform' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition', [
  'body' => '{
  "family": "",
  "taskRoleArn": "",
  "executionRoleArn": "",
  "networkMode": "",
  "containerDefinitions": "",
  "volumes": "",
  "placementConstraints": "",
  "requiresCompatibilities": "",
  "cpu": "",
  "memory": "",
  "tags": "",
  "pidMode": "",
  "ipcMode": "",
  "proxyConfiguration": "",
  "inferenceAccelerators": "",
  "ephemeralStorage": "",
  "runtimePlatform": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'family' => '',
  'taskRoleArn' => '',
  'executionRoleArn' => '',
  'networkMode' => '',
  'containerDefinitions' => '',
  'volumes' => '',
  'placementConstraints' => '',
  'requiresCompatibilities' => '',
  'cpu' => '',
  'memory' => '',
  'tags' => '',
  'pidMode' => '',
  'ipcMode' => '',
  'proxyConfiguration' => '',
  'inferenceAccelerators' => '',
  'ephemeralStorage' => '',
  'runtimePlatform' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'family' => '',
  'taskRoleArn' => '',
  'executionRoleArn' => '',
  'networkMode' => '',
  'containerDefinitions' => '',
  'volumes' => '',
  'placementConstraints' => '',
  'requiresCompatibilities' => '',
  'cpu' => '',
  'memory' => '',
  'tags' => '',
  'pidMode' => '',
  'ipcMode' => '',
  'proxyConfiguration' => '',
  'inferenceAccelerators' => '',
  'ephemeralStorage' => '',
  'runtimePlatform' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "family": "",
  "taskRoleArn": "",
  "executionRoleArn": "",
  "networkMode": "",
  "containerDefinitions": "",
  "volumes": "",
  "placementConstraints": "",
  "requiresCompatibilities": "",
  "cpu": "",
  "memory": "",
  "tags": "",
  "pidMode": "",
  "ipcMode": "",
  "proxyConfiguration": "",
  "inferenceAccelerators": "",
  "ephemeralStorage": "",
  "runtimePlatform": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "family": "",
  "taskRoleArn": "",
  "executionRoleArn": "",
  "networkMode": "",
  "containerDefinitions": "",
  "volumes": "",
  "placementConstraints": "",
  "requiresCompatibilities": "",
  "cpu": "",
  "memory": "",
  "tags": "",
  "pidMode": "",
  "ipcMode": "",
  "proxyConfiguration": "",
  "inferenceAccelerators": "",
  "ephemeralStorage": "",
  "runtimePlatform": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"family\": \"\",\n  \"taskRoleArn\": \"\",\n  \"executionRoleArn\": \"\",\n  \"networkMode\": \"\",\n  \"containerDefinitions\": \"\",\n  \"volumes\": \"\",\n  \"placementConstraints\": \"\",\n  \"requiresCompatibilities\": \"\",\n  \"cpu\": \"\",\n  \"memory\": \"\",\n  \"tags\": \"\",\n  \"pidMode\": \"\",\n  \"ipcMode\": \"\",\n  \"proxyConfiguration\": \"\",\n  \"inferenceAccelerators\": \"\",\n  \"ephemeralStorage\": \"\",\n  \"runtimePlatform\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition"

payload = {
    "family": "",
    "taskRoleArn": "",
    "executionRoleArn": "",
    "networkMode": "",
    "containerDefinitions": "",
    "volumes": "",
    "placementConstraints": "",
    "requiresCompatibilities": "",
    "cpu": "",
    "memory": "",
    "tags": "",
    "pidMode": "",
    "ipcMode": "",
    "proxyConfiguration": "",
    "inferenceAccelerators": "",
    "ephemeralStorage": "",
    "runtimePlatform": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition"

payload <- "{\n  \"family\": \"\",\n  \"taskRoleArn\": \"\",\n  \"executionRoleArn\": \"\",\n  \"networkMode\": \"\",\n  \"containerDefinitions\": \"\",\n  \"volumes\": \"\",\n  \"placementConstraints\": \"\",\n  \"requiresCompatibilities\": \"\",\n  \"cpu\": \"\",\n  \"memory\": \"\",\n  \"tags\": \"\",\n  \"pidMode\": \"\",\n  \"ipcMode\": \"\",\n  \"proxyConfiguration\": \"\",\n  \"inferenceAccelerators\": \"\",\n  \"ephemeralStorage\": \"\",\n  \"runtimePlatform\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"family\": \"\",\n  \"taskRoleArn\": \"\",\n  \"executionRoleArn\": \"\",\n  \"networkMode\": \"\",\n  \"containerDefinitions\": \"\",\n  \"volumes\": \"\",\n  \"placementConstraints\": \"\",\n  \"requiresCompatibilities\": \"\",\n  \"cpu\": \"\",\n  \"memory\": \"\",\n  \"tags\": \"\",\n  \"pidMode\": \"\",\n  \"ipcMode\": \"\",\n  \"proxyConfiguration\": \"\",\n  \"inferenceAccelerators\": \"\",\n  \"ephemeralStorage\": \"\",\n  \"runtimePlatform\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"family\": \"\",\n  \"taskRoleArn\": \"\",\n  \"executionRoleArn\": \"\",\n  \"networkMode\": \"\",\n  \"containerDefinitions\": \"\",\n  \"volumes\": \"\",\n  \"placementConstraints\": \"\",\n  \"requiresCompatibilities\": \"\",\n  \"cpu\": \"\",\n  \"memory\": \"\",\n  \"tags\": \"\",\n  \"pidMode\": \"\",\n  \"ipcMode\": \"\",\n  \"proxyConfiguration\": \"\",\n  \"inferenceAccelerators\": \"\",\n  \"ephemeralStorage\": \"\",\n  \"runtimePlatform\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition";

    let payload = json!({
        "family": "",
        "taskRoleArn": "",
        "executionRoleArn": "",
        "networkMode": "",
        "containerDefinitions": "",
        "volumes": "",
        "placementConstraints": "",
        "requiresCompatibilities": "",
        "cpu": "",
        "memory": "",
        "tags": "",
        "pidMode": "",
        "ipcMode": "",
        "proxyConfiguration": "",
        "inferenceAccelerators": "",
        "ephemeralStorage": "",
        "runtimePlatform": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "family": "",
  "taskRoleArn": "",
  "executionRoleArn": "",
  "networkMode": "",
  "containerDefinitions": "",
  "volumes": "",
  "placementConstraints": "",
  "requiresCompatibilities": "",
  "cpu": "",
  "memory": "",
  "tags": "",
  "pidMode": "",
  "ipcMode": "",
  "proxyConfiguration": "",
  "inferenceAccelerators": "",
  "ephemeralStorage": "",
  "runtimePlatform": ""
}'

echo '{
  "family": "",
  "taskRoleArn": "",
  "executionRoleArn": "",
  "networkMode": "",
  "containerDefinitions": "",
  "volumes": "",
  "placementConstraints": "",
  "requiresCompatibilities": "",
  "cpu": "",
  "memory": "",
  "tags": "",
  "pidMode": "",
  "ipcMode": "",
  "proxyConfiguration": "",
  "inferenceAccelerators": "",
  "ephemeralStorage": "",
  "runtimePlatform": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "family": "",\n  "taskRoleArn": "",\n  "executionRoleArn": "",\n  "networkMode": "",\n  "containerDefinitions": "",\n  "volumes": "",\n  "placementConstraints": "",\n  "requiresCompatibilities": "",\n  "cpu": "",\n  "memory": "",\n  "tags": "",\n  "pidMode": "",\n  "ipcMode": "",\n  "proxyConfiguration": "",\n  "inferenceAccelerators": "",\n  "ephemeralStorage": "",\n  "runtimePlatform": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "family": "",
  "taskRoleArn": "",
  "executionRoleArn": "",
  "networkMode": "",
  "containerDefinitions": "",
  "volumes": "",
  "placementConstraints": "",
  "requiresCompatibilities": "",
  "cpu": "",
  "memory": "",
  "tags": "",
  "pidMode": "",
  "ipcMode": "",
  "proxyConfiguration": "",
  "inferenceAccelerators": "",
  "ephemeralStorage": "",
  "runtimePlatform": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "taskDefinition": {
    "containerDefinitions": [
      {
        "name": "sleep",
        "command": [
          "sleep",
          "360"
        ],
        "cpu": 10,
        "environment": [],
        "essential": true,
        "image": "busybox",
        "memory": 10,
        "mountPoints": [],
        "portMappings": [],
        "volumesFrom": []
      }
    ],
    "family": "sleep360",
    "revision": 1,
    "taskDefinitionArn": "arn:aws:ecs:us-east-1::task-definition/sleep360:19",
    "volumes": []
  }
}

POST RunTask

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask

HEADERS

X-Amz-Target

BODY json

{
  "capacityProviderStrategy": "",
  "cluster": "",
  "count": "",
  "enableECSManagedTags": "",
  "enableExecuteCommand": "",
  "group": "",
  "launchType": "",
  "networkConfiguration": "",
  "overrides": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "platformVersion": "",
  "propagateTags": "",
  "referenceId": "",
  "startedBy": "",
  "tags": "",
  "taskDefinition": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"capacityProviderStrategy\": \"\",\n  \"cluster\": \"\",\n  \"count\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"launchType\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:capacityProviderStrategy ""
                                                                                                                   :cluster ""
                                                                                                                   :count ""
                                                                                                                   :enableECSManagedTags ""
                                                                                                                   :enableExecuteCommand ""
                                                                                                                   :group ""
                                                                                                                   :launchType ""
                                                                                                                   :networkConfiguration ""
                                                                                                                   :overrides ""
                                                                                                                   :placementConstraints ""
                                                                                                                   :placementStrategy ""
                                                                                                                   :platformVersion ""
                                                                                                                   :propagateTags ""
                                                                                                                   :referenceId ""
                                                                                                                   :startedBy ""
                                                                                                                   :tags ""
                                                                                                                   :taskDefinition ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"capacityProviderStrategy\": \"\",\n  \"cluster\": \"\",\n  \"count\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"launchType\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"capacityProviderStrategy\": \"\",\n  \"cluster\": \"\",\n  \"count\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"launchType\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"capacityProviderStrategy\": \"\",\n  \"cluster\": \"\",\n  \"count\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"launchType\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask"

	payload := strings.NewReader("{\n  \"capacityProviderStrategy\": \"\",\n  \"cluster\": \"\",\n  \"count\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"launchType\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 395

{
  "capacityProviderStrategy": "",
  "cluster": "",
  "count": "",
  "enableECSManagedTags": "",
  "enableExecuteCommand": "",
  "group": "",
  "launchType": "",
  "networkConfiguration": "",
  "overrides": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "platformVersion": "",
  "propagateTags": "",
  "referenceId": "",
  "startedBy": "",
  "tags": "",
  "taskDefinition": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"capacityProviderStrategy\": \"\",\n  \"cluster\": \"\",\n  \"count\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"launchType\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"capacityProviderStrategy\": \"\",\n  \"cluster\": \"\",\n  \"count\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"launchType\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"capacityProviderStrategy\": \"\",\n  \"cluster\": \"\",\n  \"count\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"launchType\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"capacityProviderStrategy\": \"\",\n  \"cluster\": \"\",\n  \"count\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"launchType\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  capacityProviderStrategy: '',
  cluster: '',
  count: '',
  enableECSManagedTags: '',
  enableExecuteCommand: '',
  group: '',
  launchType: '',
  networkConfiguration: '',
  overrides: '',
  placementConstraints: '',
  placementStrategy: '',
  platformVersion: '',
  propagateTags: '',
  referenceId: '',
  startedBy: '',
  tags: '',
  taskDefinition: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    capacityProviderStrategy: '',
    cluster: '',
    count: '',
    enableECSManagedTags: '',
    enableExecuteCommand: '',
    group: '',
    launchType: '',
    networkConfiguration: '',
    overrides: '',
    placementConstraints: '',
    placementStrategy: '',
    platformVersion: '',
    propagateTags: '',
    referenceId: '',
    startedBy: '',
    tags: '',
    taskDefinition: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"capacityProviderStrategy":"","cluster":"","count":"","enableECSManagedTags":"","enableExecuteCommand":"","group":"","launchType":"","networkConfiguration":"","overrides":"","placementConstraints":"","placementStrategy":"","platformVersion":"","propagateTags":"","referenceId":"","startedBy":"","tags":"","taskDefinition":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "capacityProviderStrategy": "",\n  "cluster": "",\n  "count": "",\n  "enableECSManagedTags": "",\n  "enableExecuteCommand": "",\n  "group": "",\n  "launchType": "",\n  "networkConfiguration": "",\n  "overrides": "",\n  "placementConstraints": "",\n  "placementStrategy": "",\n  "platformVersion": "",\n  "propagateTags": "",\n  "referenceId": "",\n  "startedBy": "",\n  "tags": "",\n  "taskDefinition": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"capacityProviderStrategy\": \"\",\n  \"cluster\": \"\",\n  \"count\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"launchType\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  capacityProviderStrategy: '',
  cluster: '',
  count: '',
  enableECSManagedTags: '',
  enableExecuteCommand: '',
  group: '',
  launchType: '',
  networkConfiguration: '',
  overrides: '',
  placementConstraints: '',
  placementStrategy: '',
  platformVersion: '',
  propagateTags: '',
  referenceId: '',
  startedBy: '',
  tags: '',
  taskDefinition: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    capacityProviderStrategy: '',
    cluster: '',
    count: '',
    enableECSManagedTags: '',
    enableExecuteCommand: '',
    group: '',
    launchType: '',
    networkConfiguration: '',
    overrides: '',
    placementConstraints: '',
    placementStrategy: '',
    platformVersion: '',
    propagateTags: '',
    referenceId: '',
    startedBy: '',
    tags: '',
    taskDefinition: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  capacityProviderStrategy: '',
  cluster: '',
  count: '',
  enableECSManagedTags: '',
  enableExecuteCommand: '',
  group: '',
  launchType: '',
  networkConfiguration: '',
  overrides: '',
  placementConstraints: '',
  placementStrategy: '',
  platformVersion: '',
  propagateTags: '',
  referenceId: '',
  startedBy: '',
  tags: '',
  taskDefinition: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    capacityProviderStrategy: '',
    cluster: '',
    count: '',
    enableECSManagedTags: '',
    enableExecuteCommand: '',
    group: '',
    launchType: '',
    networkConfiguration: '',
    overrides: '',
    placementConstraints: '',
    placementStrategy: '',
    platformVersion: '',
    propagateTags: '',
    referenceId: '',
    startedBy: '',
    tags: '',
    taskDefinition: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"capacityProviderStrategy":"","cluster":"","count":"","enableECSManagedTags":"","enableExecuteCommand":"","group":"","launchType":"","networkConfiguration":"","overrides":"","placementConstraints":"","placementStrategy":"","platformVersion":"","propagateTags":"","referenceId":"","startedBy":"","tags":"","taskDefinition":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"capacityProviderStrategy": @"",
                              @"cluster": @"",
                              @"count": @"",
                              @"enableECSManagedTags": @"",
                              @"enableExecuteCommand": @"",
                              @"group": @"",
                              @"launchType": @"",
                              @"networkConfiguration": @"",
                              @"overrides": @"",
                              @"placementConstraints": @"",
                              @"placementStrategy": @"",
                              @"platformVersion": @"",
                              @"propagateTags": @"",
                              @"referenceId": @"",
                              @"startedBy": @"",
                              @"tags": @"",
                              @"taskDefinition": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"capacityProviderStrategy\": \"\",\n  \"cluster\": \"\",\n  \"count\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"launchType\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'capacityProviderStrategy' => '',
    'cluster' => '',
    'count' => '',
    'enableECSManagedTags' => '',
    'enableExecuteCommand' => '',
    'group' => '',
    'launchType' => '',
    'networkConfiguration' => '',
    'overrides' => '',
    'placementConstraints' => '',
    'placementStrategy' => '',
    'platformVersion' => '',
    'propagateTags' => '',
    'referenceId' => '',
    'startedBy' => '',
    'tags' => '',
    'taskDefinition' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask', [
  'body' => '{
  "capacityProviderStrategy": "",
  "cluster": "",
  "count": "",
  "enableECSManagedTags": "",
  "enableExecuteCommand": "",
  "group": "",
  "launchType": "",
  "networkConfiguration": "",
  "overrides": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "platformVersion": "",
  "propagateTags": "",
  "referenceId": "",
  "startedBy": "",
  "tags": "",
  "taskDefinition": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'capacityProviderStrategy' => '',
  'cluster' => '',
  'count' => '',
  'enableECSManagedTags' => '',
  'enableExecuteCommand' => '',
  'group' => '',
  'launchType' => '',
  'networkConfiguration' => '',
  'overrides' => '',
  'placementConstraints' => '',
  'placementStrategy' => '',
  'platformVersion' => '',
  'propagateTags' => '',
  'referenceId' => '',
  'startedBy' => '',
  'tags' => '',
  'taskDefinition' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'capacityProviderStrategy' => '',
  'cluster' => '',
  'count' => '',
  'enableECSManagedTags' => '',
  'enableExecuteCommand' => '',
  'group' => '',
  'launchType' => '',
  'networkConfiguration' => '',
  'overrides' => '',
  'placementConstraints' => '',
  'placementStrategy' => '',
  'platformVersion' => '',
  'propagateTags' => '',
  'referenceId' => '',
  'startedBy' => '',
  'tags' => '',
  'taskDefinition' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "capacityProviderStrategy": "",
  "cluster": "",
  "count": "",
  "enableECSManagedTags": "",
  "enableExecuteCommand": "",
  "group": "",
  "launchType": "",
  "networkConfiguration": "",
  "overrides": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "platformVersion": "",
  "propagateTags": "",
  "referenceId": "",
  "startedBy": "",
  "tags": "",
  "taskDefinition": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "capacityProviderStrategy": "",
  "cluster": "",
  "count": "",
  "enableECSManagedTags": "",
  "enableExecuteCommand": "",
  "group": "",
  "launchType": "",
  "networkConfiguration": "",
  "overrides": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "platformVersion": "",
  "propagateTags": "",
  "referenceId": "",
  "startedBy": "",
  "tags": "",
  "taskDefinition": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"capacityProviderStrategy\": \"\",\n  \"cluster\": \"\",\n  \"count\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"launchType\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask"

payload = {
    "capacityProviderStrategy": "",
    "cluster": "",
    "count": "",
    "enableECSManagedTags": "",
    "enableExecuteCommand": "",
    "group": "",
    "launchType": "",
    "networkConfiguration": "",
    "overrides": "",
    "placementConstraints": "",
    "placementStrategy": "",
    "platformVersion": "",
    "propagateTags": "",
    "referenceId": "",
    "startedBy": "",
    "tags": "",
    "taskDefinition": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask"

payload <- "{\n  \"capacityProviderStrategy\": \"\",\n  \"cluster\": \"\",\n  \"count\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"launchType\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"capacityProviderStrategy\": \"\",\n  \"cluster\": \"\",\n  \"count\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"launchType\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"capacityProviderStrategy\": \"\",\n  \"cluster\": \"\",\n  \"count\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"launchType\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask";

    let payload = json!({
        "capacityProviderStrategy": "",
        "cluster": "",
        "count": "",
        "enableECSManagedTags": "",
        "enableExecuteCommand": "",
        "group": "",
        "launchType": "",
        "networkConfiguration": "",
        "overrides": "",
        "placementConstraints": "",
        "placementStrategy": "",
        "platformVersion": "",
        "propagateTags": "",
        "referenceId": "",
        "startedBy": "",
        "tags": "",
        "taskDefinition": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "capacityProviderStrategy": "",
  "cluster": "",
  "count": "",
  "enableECSManagedTags": "",
  "enableExecuteCommand": "",
  "group": "",
  "launchType": "",
  "networkConfiguration": "",
  "overrides": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "platformVersion": "",
  "propagateTags": "",
  "referenceId": "",
  "startedBy": "",
  "tags": "",
  "taskDefinition": ""
}'

echo '{
  "capacityProviderStrategy": "",
  "cluster": "",
  "count": "",
  "enableECSManagedTags": "",
  "enableExecuteCommand": "",
  "group": "",
  "launchType": "",
  "networkConfiguration": "",
  "overrides": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "platformVersion": "",
  "propagateTags": "",
  "referenceId": "",
  "startedBy": "",
  "tags": "",
  "taskDefinition": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "capacityProviderStrategy": "",\n  "cluster": "",\n  "count": "",\n  "enableECSManagedTags": "",\n  "enableExecuteCommand": "",\n  "group": "",\n  "launchType": "",\n  "networkConfiguration": "",\n  "overrides": "",\n  "placementConstraints": "",\n  "placementStrategy": "",\n  "platformVersion": "",\n  "propagateTags": "",\n  "referenceId": "",\n  "startedBy": "",\n  "tags": "",\n  "taskDefinition": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "capacityProviderStrategy": "",
  "cluster": "",
  "count": "",
  "enableECSManagedTags": "",
  "enableExecuteCommand": "",
  "group": "",
  "launchType": "",
  "networkConfiguration": "",
  "overrides": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "platformVersion": "",
  "propagateTags": "",
  "referenceId": "",
  "startedBy": "",
  "tags": "",
  "taskDefinition": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.RunTask")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "tasks": [
    {
      "containerInstanceArn": "arn:aws:ecs:us-east-1::container-instance/ffe3d344-77e2-476c-a4d0-bf560ad50acb",
      "containers": [
        {
          "name": "sleep",
          "containerArn": "arn:aws:ecs:us-east-1::container/58591c8e-be29-4ddf-95aa-ee459d4c59fd",
          "lastStatus": "PENDING",
          "taskArn": "arn:aws:ecs:us-east-1::task/a9f21ea7-c9f5-44b1-b8e6-b31f50ed33c0"
        }
      ],
      "desiredStatus": "RUNNING",
      "lastStatus": "PENDING",
      "overrides": {
        "containerOverrides": [
          {
            "name": "sleep"
          }
        ]
      },
      "taskArn": "arn:aws:ecs:us-east-1::task/a9f21ea7-c9f5-44b1-b8e6-b31f50ed33c0",
      "taskDefinitionArn": "arn:aws:ecs:us-east-1::task-definition/sleep360:1"
    }
  ]
}

POST StartTask

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "containerInstances": "",
  "enableECSManagedTags": "",
  "enableExecuteCommand": "",
  "group": "",
  "networkConfiguration": "",
  "overrides": "",
  "propagateTags": "",
  "referenceId": "",
  "startedBy": "",
  "tags": "",
  "taskDefinition": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:cluster ""
                                                                                                                     :containerInstances ""
                                                                                                                     :enableECSManagedTags ""
                                                                                                                     :enableExecuteCommand ""
                                                                                                                     :group ""
                                                                                                                     :networkConfiguration ""
                                                                                                                     :overrides ""
                                                                                                                     :propagateTags ""
                                                                                                                     :referenceId ""
                                                                                                                     :startedBy ""
                                                                                                                     :tags ""
                                                                                                                     :taskDefinition ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 272

{
  "cluster": "",
  "containerInstances": "",
  "enableECSManagedTags": "",
  "enableExecuteCommand": "",
  "group": "",
  "networkConfiguration": "",
  "overrides": "",
  "propagateTags": "",
  "referenceId": "",
  "startedBy": "",
  "tags": "",
  "taskDefinition": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  containerInstances: '',
  enableECSManagedTags: '',
  enableExecuteCommand: '',
  group: '',
  networkConfiguration: '',
  overrides: '',
  propagateTags: '',
  referenceId: '',
  startedBy: '',
  tags: '',
  taskDefinition: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    cluster: '',
    containerInstances: '',
    enableECSManagedTags: '',
    enableExecuteCommand: '',
    group: '',
    networkConfiguration: '',
    overrides: '',
    propagateTags: '',
    referenceId: '',
    startedBy: '',
    tags: '',
    taskDefinition: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","containerInstances":"","enableECSManagedTags":"","enableExecuteCommand":"","group":"","networkConfiguration":"","overrides":"","propagateTags":"","referenceId":"","startedBy":"","tags":"","taskDefinition":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "containerInstances": "",\n  "enableECSManagedTags": "",\n  "enableExecuteCommand": "",\n  "group": "",\n  "networkConfiguration": "",\n  "overrides": "",\n  "propagateTags": "",\n  "referenceId": "",\n  "startedBy": "",\n  "tags": "",\n  "taskDefinition": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  cluster: '',
  containerInstances: '',
  enableECSManagedTags: '',
  enableExecuteCommand: '',
  group: '',
  networkConfiguration: '',
  overrides: '',
  propagateTags: '',
  referenceId: '',
  startedBy: '',
  tags: '',
  taskDefinition: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    cluster: '',
    containerInstances: '',
    enableECSManagedTags: '',
    enableExecuteCommand: '',
    group: '',
    networkConfiguration: '',
    overrides: '',
    propagateTags: '',
    referenceId: '',
    startedBy: '',
    tags: '',
    taskDefinition: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  containerInstances: '',
  enableECSManagedTags: '',
  enableExecuteCommand: '',
  group: '',
  networkConfiguration: '',
  overrides: '',
  propagateTags: '',
  referenceId: '',
  startedBy: '',
  tags: '',
  taskDefinition: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    cluster: '',
    containerInstances: '',
    enableECSManagedTags: '',
    enableExecuteCommand: '',
    group: '',
    networkConfiguration: '',
    overrides: '',
    propagateTags: '',
    referenceId: '',
    startedBy: '',
    tags: '',
    taskDefinition: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","containerInstances":"","enableECSManagedTags":"","enableExecuteCommand":"","group":"","networkConfiguration":"","overrides":"","propagateTags":"","referenceId":"","startedBy":"","tags":"","taskDefinition":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"containerInstances": @"",
                              @"enableECSManagedTags": @"",
                              @"enableExecuteCommand": @"",
                              @"group": @"",
                              @"networkConfiguration": @"",
                              @"overrides": @"",
                              @"propagateTags": @"",
                              @"referenceId": @"",
                              @"startedBy": @"",
                              @"tags": @"",
                              @"taskDefinition": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'containerInstances' => '',
    'enableECSManagedTags' => '',
    'enableExecuteCommand' => '',
    'group' => '',
    'networkConfiguration' => '',
    'overrides' => '',
    'propagateTags' => '',
    'referenceId' => '',
    'startedBy' => '',
    'tags' => '',
    'taskDefinition' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask', [
  'body' => '{
  "cluster": "",
  "containerInstances": "",
  "enableECSManagedTags": "",
  "enableExecuteCommand": "",
  "group": "",
  "networkConfiguration": "",
  "overrides": "",
  "propagateTags": "",
  "referenceId": "",
  "startedBy": "",
  "tags": "",
  "taskDefinition": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'containerInstances' => '',
  'enableECSManagedTags' => '',
  'enableExecuteCommand' => '',
  'group' => '',
  'networkConfiguration' => '',
  'overrides' => '',
  'propagateTags' => '',
  'referenceId' => '',
  'startedBy' => '',
  'tags' => '',
  'taskDefinition' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'containerInstances' => '',
  'enableECSManagedTags' => '',
  'enableExecuteCommand' => '',
  'group' => '',
  'networkConfiguration' => '',
  'overrides' => '',
  'propagateTags' => '',
  'referenceId' => '',
  'startedBy' => '',
  'tags' => '',
  'taskDefinition' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "containerInstances": "",
  "enableECSManagedTags": "",
  "enableExecuteCommand": "",
  "group": "",
  "networkConfiguration": "",
  "overrides": "",
  "propagateTags": "",
  "referenceId": "",
  "startedBy": "",
  "tags": "",
  "taskDefinition": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "containerInstances": "",
  "enableECSManagedTags": "",
  "enableExecuteCommand": "",
  "group": "",
  "networkConfiguration": "",
  "overrides": "",
  "propagateTags": "",
  "referenceId": "",
  "startedBy": "",
  "tags": "",
  "taskDefinition": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask"

payload = {
    "cluster": "",
    "containerInstances": "",
    "enableECSManagedTags": "",
    "enableExecuteCommand": "",
    "group": "",
    "networkConfiguration": "",
    "overrides": "",
    "propagateTags": "",
    "referenceId": "",
    "startedBy": "",
    "tags": "",
    "taskDefinition": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask"

payload <- "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"group\": \"\",\n  \"networkConfiguration\": \"\",\n  \"overrides\": \"\",\n  \"propagateTags\": \"\",\n  \"referenceId\": \"\",\n  \"startedBy\": \"\",\n  \"tags\": \"\",\n  \"taskDefinition\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask";

    let payload = json!({
        "cluster": "",
        "containerInstances": "",
        "enableECSManagedTags": "",
        "enableExecuteCommand": "",
        "group": "",
        "networkConfiguration": "",
        "overrides": "",
        "propagateTags": "",
        "referenceId": "",
        "startedBy": "",
        "tags": "",
        "taskDefinition": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "containerInstances": "",
  "enableECSManagedTags": "",
  "enableExecuteCommand": "",
  "group": "",
  "networkConfiguration": "",
  "overrides": "",
  "propagateTags": "",
  "referenceId": "",
  "startedBy": "",
  "tags": "",
  "taskDefinition": ""
}'

echo '{
  "cluster": "",
  "containerInstances": "",
  "enableECSManagedTags": "",
  "enableExecuteCommand": "",
  "group": "",
  "networkConfiguration": "",
  "overrides": "",
  "propagateTags": "",
  "referenceId": "",
  "startedBy": "",
  "tags": "",
  "taskDefinition": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "containerInstances": "",\n  "enableECSManagedTags": "",\n  "enableExecuteCommand": "",\n  "group": "",\n  "networkConfiguration": "",\n  "overrides": "",\n  "propagateTags": "",\n  "referenceId": "",\n  "startedBy": "",\n  "tags": "",\n  "taskDefinition": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "containerInstances": "",
  "enableECSManagedTags": "",
  "enableExecuteCommand": "",
  "group": "",
  "networkConfiguration": "",
  "overrides": "",
  "propagateTags": "",
  "referenceId": "",
  "startedBy": "",
  "tags": "",
  "taskDefinition": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StartTask")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST StopTask

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "task": "",
  "reason": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"reason\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:cluster ""
                                                                                                                    :task ""
                                                                                                                    :reason ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"reason\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"reason\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"reason\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"reason\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 49

{
  "cluster": "",
  "task": "",
  "reason": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"reason\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"reason\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"reason\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"reason\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  task: '',
  reason: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', task: '', reason: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","task":"","reason":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "task": "",\n  "reason": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"reason\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', task: '', reason: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', task: '', reason: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  task: '',
  reason: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', task: '', reason: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","task":"","reason":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"task": @"",
                              @"reason": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"reason\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'task' => '',
    'reason' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask', [
  'body' => '{
  "cluster": "",
  "task": "",
  "reason": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'task' => '',
  'reason' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'task' => '',
  'reason' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "task": "",
  "reason": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "task": "",
  "reason": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"reason\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask"

payload = {
    "cluster": "",
    "task": "",
    "reason": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask"

payload <- "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"reason\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"reason\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"reason\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask";

    let payload = json!({
        "cluster": "",
        "task": "",
        "reason": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "task": "",
  "reason": ""
}'

echo '{
  "cluster": "",
  "task": "",
  "reason": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "task": "",\n  "reason": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "task": "",
  "reason": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.StopTask")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST SubmitAttachmentStateChanges

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "attachments": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"attachments\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges" {:headers {:x-amz-target ""}
                                                                                                                          :content-type :json
                                                                                                                          :form-params {:cluster ""
                                                                                                                                        :attachments ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"attachments\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"attachments\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"attachments\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"attachments\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "cluster": "",
  "attachments": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"attachments\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"attachments\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"attachments\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"attachments\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  attachments: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', attachments: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","attachments":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "attachments": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"attachments\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', attachments: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', attachments: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  attachments: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', attachments: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","attachments":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"attachments": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"attachments\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'attachments' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges', [
  'body' => '{
  "cluster": "",
  "attachments": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'attachments' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'attachments' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "attachments": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "attachments": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"attachments\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges"

payload = {
    "cluster": "",
    "attachments": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges"

payload <- "{\n  \"cluster\": \"\",\n  \"attachments\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"attachments\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"attachments\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges";

    let payload = json!({
        "cluster": "",
        "attachments": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "attachments": ""
}'

echo '{
  "cluster": "",
  "attachments": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "attachments": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "attachments": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST SubmitContainerStateChange

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "task": "",
  "containerName": "",
  "runtimeId": "",
  "status": "",
  "exitCode": "",
  "reason": "",
  "networkBindings": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"containerName\": \"\",\n  \"runtimeId\": \"\",\n  \"status\": \"\",\n  \"exitCode\": \"\",\n  \"reason\": \"\",\n  \"networkBindings\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange" {:headers {:x-amz-target ""}
                                                                                                                        :content-type :json
                                                                                                                        :form-params {:cluster ""
                                                                                                                                      :task ""
                                                                                                                                      :containerName ""
                                                                                                                                      :runtimeId ""
                                                                                                                                      :status ""
                                                                                                                                      :exitCode ""
                                                                                                                                      :reason ""
                                                                                                                                      :networkBindings ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"containerName\": \"\",\n  \"runtimeId\": \"\",\n  \"status\": \"\",\n  \"exitCode\": \"\",\n  \"reason\": \"\",\n  \"networkBindings\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"containerName\": \"\",\n  \"runtimeId\": \"\",\n  \"status\": \"\",\n  \"exitCode\": \"\",\n  \"reason\": \"\",\n  \"networkBindings\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"containerName\": \"\",\n  \"runtimeId\": \"\",\n  \"status\": \"\",\n  \"exitCode\": \"\",\n  \"reason\": \"\",\n  \"networkBindings\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"containerName\": \"\",\n  \"runtimeId\": \"\",\n  \"status\": \"\",\n  \"exitCode\": \"\",\n  \"reason\": \"\",\n  \"networkBindings\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 150

{
  "cluster": "",
  "task": "",
  "containerName": "",
  "runtimeId": "",
  "status": "",
  "exitCode": "",
  "reason": "",
  "networkBindings": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"containerName\": \"\",\n  \"runtimeId\": \"\",\n  \"status\": \"\",\n  \"exitCode\": \"\",\n  \"reason\": \"\",\n  \"networkBindings\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"containerName\": \"\",\n  \"runtimeId\": \"\",\n  \"status\": \"\",\n  \"exitCode\": \"\",\n  \"reason\": \"\",\n  \"networkBindings\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"containerName\": \"\",\n  \"runtimeId\": \"\",\n  \"status\": \"\",\n  \"exitCode\": \"\",\n  \"reason\": \"\",\n  \"networkBindings\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"containerName\": \"\",\n  \"runtimeId\": \"\",\n  \"status\": \"\",\n  \"exitCode\": \"\",\n  \"reason\": \"\",\n  \"networkBindings\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  task: '',
  containerName: '',
  runtimeId: '',
  status: '',
  exitCode: '',
  reason: '',
  networkBindings: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    cluster: '',
    task: '',
    containerName: '',
    runtimeId: '',
    status: '',
    exitCode: '',
    reason: '',
    networkBindings: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","task":"","containerName":"","runtimeId":"","status":"","exitCode":"","reason":"","networkBindings":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "task": "",\n  "containerName": "",\n  "runtimeId": "",\n  "status": "",\n  "exitCode": "",\n  "reason": "",\n  "networkBindings": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"containerName\": \"\",\n  \"runtimeId\": \"\",\n  \"status\": \"\",\n  \"exitCode\": \"\",\n  \"reason\": \"\",\n  \"networkBindings\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  cluster: '',
  task: '',
  containerName: '',
  runtimeId: '',
  status: '',
  exitCode: '',
  reason: '',
  networkBindings: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    cluster: '',
    task: '',
    containerName: '',
    runtimeId: '',
    status: '',
    exitCode: '',
    reason: '',
    networkBindings: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  task: '',
  containerName: '',
  runtimeId: '',
  status: '',
  exitCode: '',
  reason: '',
  networkBindings: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    cluster: '',
    task: '',
    containerName: '',
    runtimeId: '',
    status: '',
    exitCode: '',
    reason: '',
    networkBindings: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","task":"","containerName":"","runtimeId":"","status":"","exitCode":"","reason":"","networkBindings":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"task": @"",
                              @"containerName": @"",
                              @"runtimeId": @"",
                              @"status": @"",
                              @"exitCode": @"",
                              @"reason": @"",
                              @"networkBindings": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"containerName\": \"\",\n  \"runtimeId\": \"\",\n  \"status\": \"\",\n  \"exitCode\": \"\",\n  \"reason\": \"\",\n  \"networkBindings\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'task' => '',
    'containerName' => '',
    'runtimeId' => '',
    'status' => '',
    'exitCode' => '',
    'reason' => '',
    'networkBindings' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange', [
  'body' => '{
  "cluster": "",
  "task": "",
  "containerName": "",
  "runtimeId": "",
  "status": "",
  "exitCode": "",
  "reason": "",
  "networkBindings": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'task' => '',
  'containerName' => '',
  'runtimeId' => '',
  'status' => '',
  'exitCode' => '',
  'reason' => '',
  'networkBindings' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'task' => '',
  'containerName' => '',
  'runtimeId' => '',
  'status' => '',
  'exitCode' => '',
  'reason' => '',
  'networkBindings' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "task": "",
  "containerName": "",
  "runtimeId": "",
  "status": "",
  "exitCode": "",
  "reason": "",
  "networkBindings": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "task": "",
  "containerName": "",
  "runtimeId": "",
  "status": "",
  "exitCode": "",
  "reason": "",
  "networkBindings": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"containerName\": \"\",\n  \"runtimeId\": \"\",\n  \"status\": \"\",\n  \"exitCode\": \"\",\n  \"reason\": \"\",\n  \"networkBindings\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange"

payload = {
    "cluster": "",
    "task": "",
    "containerName": "",
    "runtimeId": "",
    "status": "",
    "exitCode": "",
    "reason": "",
    "networkBindings": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange"

payload <- "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"containerName\": \"\",\n  \"runtimeId\": \"\",\n  \"status\": \"\",\n  \"exitCode\": \"\",\n  \"reason\": \"\",\n  \"networkBindings\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"containerName\": \"\",\n  \"runtimeId\": \"\",\n  \"status\": \"\",\n  \"exitCode\": \"\",\n  \"reason\": \"\",\n  \"networkBindings\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"containerName\": \"\",\n  \"runtimeId\": \"\",\n  \"status\": \"\",\n  \"exitCode\": \"\",\n  \"reason\": \"\",\n  \"networkBindings\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange";

    let payload = json!({
        "cluster": "",
        "task": "",
        "containerName": "",
        "runtimeId": "",
        "status": "",
        "exitCode": "",
        "reason": "",
        "networkBindings": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "task": "",
  "containerName": "",
  "runtimeId": "",
  "status": "",
  "exitCode": "",
  "reason": "",
  "networkBindings": ""
}'

echo '{
  "cluster": "",
  "task": "",
  "containerName": "",
  "runtimeId": "",
  "status": "",
  "exitCode": "",
  "reason": "",
  "networkBindings": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "task": "",\n  "containerName": "",\n  "runtimeId": "",\n  "status": "",\n  "exitCode": "",\n  "reason": "",\n  "networkBindings": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "task": "",
  "containerName": "",
  "runtimeId": "",
  "status": "",
  "exitCode": "",
  "reason": "",
  "networkBindings": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST SubmitTaskStateChange

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "task": "",
  "status": "",
  "reason": "",
  "containers": "",
  "attachments": "",
  "managedAgents": "",
  "pullStartedAt": "",
  "pullStoppedAt": "",
  "executionStoppedAt": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"status\": \"\",\n  \"reason\": \"\",\n  \"containers\": \"\",\n  \"attachments\": \"\",\n  \"managedAgents\": \"\",\n  \"pullStartedAt\": \"\",\n  \"pullStoppedAt\": \"\",\n  \"executionStoppedAt\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:cluster ""
                                                                                                                                 :task ""
                                                                                                                                 :status ""
                                                                                                                                 :reason ""
                                                                                                                                 :containers ""
                                                                                                                                 :attachments ""
                                                                                                                                 :managedAgents ""
                                                                                                                                 :pullStartedAt ""
                                                                                                                                 :pullStoppedAt ""
                                                                                                                                 :executionStoppedAt ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"status\": \"\",\n  \"reason\": \"\",\n  \"containers\": \"\",\n  \"attachments\": \"\",\n  \"managedAgents\": \"\",\n  \"pullStartedAt\": \"\",\n  \"pullStoppedAt\": \"\",\n  \"executionStoppedAt\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"status\": \"\",\n  \"reason\": \"\",\n  \"containers\": \"\",\n  \"attachments\": \"\",\n  \"managedAgents\": \"\",\n  \"pullStartedAt\": \"\",\n  \"pullStoppedAt\": \"\",\n  \"executionStoppedAt\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"status\": \"\",\n  \"reason\": \"\",\n  \"containers\": \"\",\n  \"attachments\": \"\",\n  \"managedAgents\": \"\",\n  \"pullStartedAt\": \"\",\n  \"pullStoppedAt\": \"\",\n  \"executionStoppedAt\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"status\": \"\",\n  \"reason\": \"\",\n  \"containers\": \"\",\n  \"attachments\": \"\",\n  \"managedAgents\": \"\",\n  \"pullStartedAt\": \"\",\n  \"pullStoppedAt\": \"\",\n  \"executionStoppedAt\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 203

{
  "cluster": "",
  "task": "",
  "status": "",
  "reason": "",
  "containers": "",
  "attachments": "",
  "managedAgents": "",
  "pullStartedAt": "",
  "pullStoppedAt": "",
  "executionStoppedAt": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"status\": \"\",\n  \"reason\": \"\",\n  \"containers\": \"\",\n  \"attachments\": \"\",\n  \"managedAgents\": \"\",\n  \"pullStartedAt\": \"\",\n  \"pullStoppedAt\": \"\",\n  \"executionStoppedAt\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"status\": \"\",\n  \"reason\": \"\",\n  \"containers\": \"\",\n  \"attachments\": \"\",\n  \"managedAgents\": \"\",\n  \"pullStartedAt\": \"\",\n  \"pullStoppedAt\": \"\",\n  \"executionStoppedAt\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"status\": \"\",\n  \"reason\": \"\",\n  \"containers\": \"\",\n  \"attachments\": \"\",\n  \"managedAgents\": \"\",\n  \"pullStartedAt\": \"\",\n  \"pullStoppedAt\": \"\",\n  \"executionStoppedAt\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"status\": \"\",\n  \"reason\": \"\",\n  \"containers\": \"\",\n  \"attachments\": \"\",\n  \"managedAgents\": \"\",\n  \"pullStartedAt\": \"\",\n  \"pullStoppedAt\": \"\",\n  \"executionStoppedAt\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  task: '',
  status: '',
  reason: '',
  containers: '',
  attachments: '',
  managedAgents: '',
  pullStartedAt: '',
  pullStoppedAt: '',
  executionStoppedAt: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    cluster: '',
    task: '',
    status: '',
    reason: '',
    containers: '',
    attachments: '',
    managedAgents: '',
    pullStartedAt: '',
    pullStoppedAt: '',
    executionStoppedAt: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","task":"","status":"","reason":"","containers":"","attachments":"","managedAgents":"","pullStartedAt":"","pullStoppedAt":"","executionStoppedAt":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "task": "",\n  "status": "",\n  "reason": "",\n  "containers": "",\n  "attachments": "",\n  "managedAgents": "",\n  "pullStartedAt": "",\n  "pullStoppedAt": "",\n  "executionStoppedAt": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"status\": \"\",\n  \"reason\": \"\",\n  \"containers\": \"\",\n  \"attachments\": \"\",\n  \"managedAgents\": \"\",\n  \"pullStartedAt\": \"\",\n  \"pullStoppedAt\": \"\",\n  \"executionStoppedAt\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  cluster: '',
  task: '',
  status: '',
  reason: '',
  containers: '',
  attachments: '',
  managedAgents: '',
  pullStartedAt: '',
  pullStoppedAt: '',
  executionStoppedAt: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    cluster: '',
    task: '',
    status: '',
    reason: '',
    containers: '',
    attachments: '',
    managedAgents: '',
    pullStartedAt: '',
    pullStoppedAt: '',
    executionStoppedAt: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  task: '',
  status: '',
  reason: '',
  containers: '',
  attachments: '',
  managedAgents: '',
  pullStartedAt: '',
  pullStoppedAt: '',
  executionStoppedAt: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    cluster: '',
    task: '',
    status: '',
    reason: '',
    containers: '',
    attachments: '',
    managedAgents: '',
    pullStartedAt: '',
    pullStoppedAt: '',
    executionStoppedAt: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","task":"","status":"","reason":"","containers":"","attachments":"","managedAgents":"","pullStartedAt":"","pullStoppedAt":"","executionStoppedAt":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"task": @"",
                              @"status": @"",
                              @"reason": @"",
                              @"containers": @"",
                              @"attachments": @"",
                              @"managedAgents": @"",
                              @"pullStartedAt": @"",
                              @"pullStoppedAt": @"",
                              @"executionStoppedAt": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"status\": \"\",\n  \"reason\": \"\",\n  \"containers\": \"\",\n  \"attachments\": \"\",\n  \"managedAgents\": \"\",\n  \"pullStartedAt\": \"\",\n  \"pullStoppedAt\": \"\",\n  \"executionStoppedAt\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'task' => '',
    'status' => '',
    'reason' => '',
    'containers' => '',
    'attachments' => '',
    'managedAgents' => '',
    'pullStartedAt' => '',
    'pullStoppedAt' => '',
    'executionStoppedAt' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange', [
  'body' => '{
  "cluster": "",
  "task": "",
  "status": "",
  "reason": "",
  "containers": "",
  "attachments": "",
  "managedAgents": "",
  "pullStartedAt": "",
  "pullStoppedAt": "",
  "executionStoppedAt": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'task' => '',
  'status' => '',
  'reason' => '',
  'containers' => '',
  'attachments' => '',
  'managedAgents' => '',
  'pullStartedAt' => '',
  'pullStoppedAt' => '',
  'executionStoppedAt' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'task' => '',
  'status' => '',
  'reason' => '',
  'containers' => '',
  'attachments' => '',
  'managedAgents' => '',
  'pullStartedAt' => '',
  'pullStoppedAt' => '',
  'executionStoppedAt' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "task": "",
  "status": "",
  "reason": "",
  "containers": "",
  "attachments": "",
  "managedAgents": "",
  "pullStartedAt": "",
  "pullStoppedAt": "",
  "executionStoppedAt": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "task": "",
  "status": "",
  "reason": "",
  "containers": "",
  "attachments": "",
  "managedAgents": "",
  "pullStartedAt": "",
  "pullStoppedAt": "",
  "executionStoppedAt": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"status\": \"\",\n  \"reason\": \"\",\n  \"containers\": \"\",\n  \"attachments\": \"\",\n  \"managedAgents\": \"\",\n  \"pullStartedAt\": \"\",\n  \"pullStoppedAt\": \"\",\n  \"executionStoppedAt\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange"

payload = {
    "cluster": "",
    "task": "",
    "status": "",
    "reason": "",
    "containers": "",
    "attachments": "",
    "managedAgents": "",
    "pullStartedAt": "",
    "pullStoppedAt": "",
    "executionStoppedAt": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange"

payload <- "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"status\": \"\",\n  \"reason\": \"\",\n  \"containers\": \"\",\n  \"attachments\": \"\",\n  \"managedAgents\": \"\",\n  \"pullStartedAt\": \"\",\n  \"pullStoppedAt\": \"\",\n  \"executionStoppedAt\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"status\": \"\",\n  \"reason\": \"\",\n  \"containers\": \"\",\n  \"attachments\": \"\",\n  \"managedAgents\": \"\",\n  \"pullStartedAt\": \"\",\n  \"pullStoppedAt\": \"\",\n  \"executionStoppedAt\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"task\": \"\",\n  \"status\": \"\",\n  \"reason\": \"\",\n  \"containers\": \"\",\n  \"attachments\": \"\",\n  \"managedAgents\": \"\",\n  \"pullStartedAt\": \"\",\n  \"pullStoppedAt\": \"\",\n  \"executionStoppedAt\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange";

    let payload = json!({
        "cluster": "",
        "task": "",
        "status": "",
        "reason": "",
        "containers": "",
        "attachments": "",
        "managedAgents": "",
        "pullStartedAt": "",
        "pullStoppedAt": "",
        "executionStoppedAt": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "task": "",
  "status": "",
  "reason": "",
  "containers": "",
  "attachments": "",
  "managedAgents": "",
  "pullStartedAt": "",
  "pullStoppedAt": "",
  "executionStoppedAt": ""
}'

echo '{
  "cluster": "",
  "task": "",
  "status": "",
  "reason": "",
  "containers": "",
  "attachments": "",
  "managedAgents": "",
  "pullStartedAt": "",
  "pullStoppedAt": "",
  "executionStoppedAt": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "task": "",\n  "status": "",\n  "reason": "",\n  "containers": "",\n  "attachments": "",\n  "managedAgents": "",\n  "pullStartedAt": "",\n  "pullStoppedAt": "",\n  "executionStoppedAt": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "task": "",
  "status": "",
  "reason": "",
  "containers": "",
  "attachments": "",
  "managedAgents": "",
  "pullStartedAt": "",
  "pullStoppedAt": "",
  "executionStoppedAt": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST TagResource

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource

HEADERS

X-Amz-Target

BODY json

{
  "resourceArn": "",
  "tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:resourceArn ""
                                                                                                                       :tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource"

	payload := strings.NewReader("{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 37

{
  "resourceArn": "",
  "tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resourceArn: '',
  tags: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {resourceArn: '', tags: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"resourceArn":"","tags":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceArn": "",\n  "tags": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({resourceArn: '', tags: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {resourceArn: '', tags: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  resourceArn: '',
  tags: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {resourceArn: '', tags: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"resourceArn":"","tags":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"resourceArn": @"",
                              @"tags": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'resourceArn' => '',
    'tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource', [
  'body' => '{
  "resourceArn": "",
  "tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceArn' => '',
  'tags' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'resourceArn' => '',
  'tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceArn": "",
  "tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceArn": "",
  "tags": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource"

payload = {
    "resourceArn": "",
    "tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource"

payload <- "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource";

    let payload = json!({
        "resourceArn": "",
        "tags": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "resourceArn": "",
  "tags": ""
}'

echo '{
  "resourceArn": "",
  "tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceArn": "",\n  "tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "resourceArn": "",
  "tags": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.TagResource")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{}

POST UntagResource

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource

HEADERS

X-Amz-Target

BODY json

{
  "resourceArn": "",
  "tagKeys": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:resourceArn ""
                                                                                                                         :tagKeys ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource"

	payload := strings.NewReader("{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "resourceArn": "",
  "tagKeys": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resourceArn: '',
  tagKeys: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {resourceArn: '', tagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"resourceArn":"","tagKeys":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceArn": "",\n  "tagKeys": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({resourceArn: '', tagKeys: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {resourceArn: '', tagKeys: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  resourceArn: '',
  tagKeys: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {resourceArn: '', tagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"resourceArn":"","tagKeys":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"resourceArn": @"",
                              @"tagKeys": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'resourceArn' => '',
    'tagKeys' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource', [
  'body' => '{
  "resourceArn": "",
  "tagKeys": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceArn' => '',
  'tagKeys' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'resourceArn' => '',
  'tagKeys' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceArn": "",
  "tagKeys": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceArn": "",
  "tagKeys": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource"

payload = {
    "resourceArn": "",
    "tagKeys": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource"

payload <- "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource";

    let payload = json!({
        "resourceArn": "",
        "tagKeys": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "resourceArn": "",
  "tagKeys": ""
}'

echo '{
  "resourceArn": "",
  "tagKeys": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceArn": "",\n  "tagKeys": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "resourceArn": "",
  "tagKeys": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UntagResource")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{}

POST UpdateCapacityProvider

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider

HEADERS

X-Amz-Target

BODY json

{
  "name": "",
  "autoScalingGroupProvider": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:name ""
                                                                                                                                  :autoScalingGroupProvider ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 50

{
  "name": "",
  "autoScalingGroupProvider": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  autoScalingGroupProvider: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: '', autoScalingGroupProvider: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","autoScalingGroupProvider":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "autoScalingGroupProvider": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({name: '', autoScalingGroupProvider: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {name: '', autoScalingGroupProvider: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: '',
  autoScalingGroupProvider: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: '', autoScalingGroupProvider: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","autoScalingGroupProvider":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"",
                              @"autoScalingGroupProvider": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'autoScalingGroupProvider' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider', [
  'body' => '{
  "name": "",
  "autoScalingGroupProvider": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'autoScalingGroupProvider' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => '',
  'autoScalingGroupProvider' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "autoScalingGroupProvider": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "autoScalingGroupProvider": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider"

payload = {
    "name": "",
    "autoScalingGroupProvider": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider"

payload <- "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"name\": \"\",\n  \"autoScalingGroupProvider\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider";

    let payload = json!({
        "name": "",
        "autoScalingGroupProvider": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": "",
  "autoScalingGroupProvider": ""
}'

echo '{
  "name": "",
  "autoScalingGroupProvider": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "autoScalingGroupProvider": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "name": "",
  "autoScalingGroupProvider": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateCluster

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "settings": "",
  "configuration": "",
  "serviceConnectDefaults": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:cluster ""
                                                                                                                         :settings ""
                                                                                                                         :configuration ""
                                                                                                                         :serviceConnectDefaults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 92

{
  "cluster": "",
  "settings": "",
  "configuration": "",
  "serviceConnectDefaults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  settings: '',
  configuration: '',
  serviceConnectDefaults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', settings: '', configuration: '', serviceConnectDefaults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","settings":"","configuration":"","serviceConnectDefaults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "settings": "",\n  "configuration": "",\n  "serviceConnectDefaults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', settings: '', configuration: '', serviceConnectDefaults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', settings: '', configuration: '', serviceConnectDefaults: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  settings: '',
  configuration: '',
  serviceConnectDefaults: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', settings: '', configuration: '', serviceConnectDefaults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","settings":"","configuration":"","serviceConnectDefaults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"settings": @"",
                              @"configuration": @"",
                              @"serviceConnectDefaults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'settings' => '',
    'configuration' => '',
    'serviceConnectDefaults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster', [
  'body' => '{
  "cluster": "",
  "settings": "",
  "configuration": "",
  "serviceConnectDefaults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'settings' => '',
  'configuration' => '',
  'serviceConnectDefaults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'settings' => '',
  'configuration' => '',
  'serviceConnectDefaults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "settings": "",
  "configuration": "",
  "serviceConnectDefaults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "settings": "",
  "configuration": "",
  "serviceConnectDefaults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster"

payload = {
    "cluster": "",
    "settings": "",
    "configuration": "",
    "serviceConnectDefaults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster"

payload <- "{\n  \"cluster\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"settings\": \"\",\n  \"configuration\": \"\",\n  \"serviceConnectDefaults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster";

    let payload = json!({
        "cluster": "",
        "settings": "",
        "configuration": "",
        "serviceConnectDefaults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "settings": "",
  "configuration": "",
  "serviceConnectDefaults": ""
}'

echo '{
  "cluster": "",
  "settings": "",
  "configuration": "",
  "serviceConnectDefaults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "settings": "",\n  "configuration": "",\n  "serviceConnectDefaults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "settings": "",
  "configuration": "",
  "serviceConnectDefaults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateCluster")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateClusterSettings

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "settings": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"settings\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:cluster ""
                                                                                                                                 :settings ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"settings\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"settings\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"settings\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"settings\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 37

{
  "cluster": "",
  "settings": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"settings\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"settings\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"settings\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"settings\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  settings: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', settings: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","settings":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "settings": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"settings\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', settings: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', settings: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  settings: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', settings: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","settings":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"settings": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"settings\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'settings' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings', [
  'body' => '{
  "cluster": "",
  "settings": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'settings' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'settings' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "settings": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "settings": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"settings\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings"

payload = {
    "cluster": "",
    "settings": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings"

payload <- "{\n  \"cluster\": \"\",\n  \"settings\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"settings\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"settings\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings";

    let payload = json!({
        "cluster": "",
        "settings": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "settings": ""
}'

echo '{
  "cluster": "",
  "settings": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "settings": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "settings": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateClusterSettings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateContainerAgent

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "containerInstance": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent" {:headers {:x-amz-target ""}
                                                                                                                  :content-type :json
                                                                                                                  :form-params {:cluster ""
                                                                                                                                :containerInstance ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 46

{
  "cluster": "",
  "containerInstance": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  containerInstance: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', containerInstance: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","containerInstance":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "containerInstance": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', containerInstance: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', containerInstance: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  containerInstance: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', containerInstance: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","containerInstance":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"containerInstance": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'containerInstance' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent', [
  'body' => '{
  "cluster": "",
  "containerInstance": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'containerInstance' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'containerInstance' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "containerInstance": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "containerInstance": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent"

payload = {
    "cluster": "",
    "containerInstance": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent"

payload <- "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"containerInstance\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent";

    let payload = json!({
        "cluster": "",
        "containerInstance": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "containerInstance": ""
}'

echo '{
  "cluster": "",
  "containerInstance": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "containerInstance": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "containerInstance": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerAgent")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateContainerInstancesState

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "containerInstances": "",
  "status": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState" {:headers {:x-amz-target ""}
                                                                                                                           :content-type :json
                                                                                                                           :form-params {:cluster ""
                                                                                                                                         :containerInstances ""
                                                                                                                                         :status ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"status\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"status\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 63

{
  "cluster": "",
  "containerInstances": "",
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  containerInstances: '',
  status: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', containerInstances: '', status: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","containerInstances":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "containerInstances": "",\n  "status": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', containerInstances: '', status: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', containerInstances: '', status: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  containerInstances: '',
  status: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', containerInstances: '', status: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","containerInstances":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"containerInstances": @"",
                              @"status": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"status\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'containerInstances' => '',
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState', [
  'body' => '{
  "cluster": "",
  "containerInstances": "",
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'containerInstances' => '',
  'status' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'containerInstances' => '',
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "containerInstances": "",
  "status": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "containerInstances": "",
  "status": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"status\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState"

payload = {
    "cluster": "",
    "containerInstances": "",
    "status": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState"

payload <- "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"status\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"status\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"containerInstances\": \"\",\n  \"status\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState";

    let payload = json!({
        "cluster": "",
        "containerInstances": "",
        "status": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "containerInstances": "",
  "status": ""
}'

echo '{
  "cluster": "",
  "containerInstances": "",
  "status": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "containerInstances": "",\n  "status": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "containerInstances": "",
  "status": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateService

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "service": "",
  "desiredCount": "",
  "taskDefinition": "",
  "capacityProviderStrategy": "",
  "deploymentConfiguration": "",
  "networkConfiguration": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "platformVersion": "",
  "forceNewDeployment": "",
  "healthCheckGracePeriodSeconds": "",
  "enableExecuteCommand": "",
  "enableECSManagedTags": "",
  "loadBalancers": "",
  "propagateTags": "",
  "serviceRegistries": "",
  "serviceConnectConfiguration": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"desiredCount\": \"\",\n  \"taskDefinition\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"networkConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"forceNewDeployment\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"loadBalancers\": \"\",\n  \"propagateTags\": \"\",\n  \"serviceRegistries\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:cluster ""
                                                                                                                         :service ""
                                                                                                                         :desiredCount ""
                                                                                                                         :taskDefinition ""
                                                                                                                         :capacityProviderStrategy ""
                                                                                                                         :deploymentConfiguration ""
                                                                                                                         :networkConfiguration ""
                                                                                                                         :placementConstraints ""
                                                                                                                         :placementStrategy ""
                                                                                                                         :platformVersion ""
                                                                                                                         :forceNewDeployment ""
                                                                                                                         :healthCheckGracePeriodSeconds ""
                                                                                                                         :enableExecuteCommand ""
                                                                                                                         :enableECSManagedTags ""
                                                                                                                         :loadBalancers ""
                                                                                                                         :propagateTags ""
                                                                                                                         :serviceRegistries ""
                                                                                                                         :serviceConnectConfiguration ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"desiredCount\": \"\",\n  \"taskDefinition\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"networkConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"forceNewDeployment\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"loadBalancers\": \"\",\n  \"propagateTags\": \"\",\n  \"serviceRegistries\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"desiredCount\": \"\",\n  \"taskDefinition\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"networkConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"forceNewDeployment\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"loadBalancers\": \"\",\n  \"propagateTags\": \"\",\n  \"serviceRegistries\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"desiredCount\": \"\",\n  \"taskDefinition\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"networkConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"forceNewDeployment\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"loadBalancers\": \"\",\n  \"propagateTags\": \"\",\n  \"serviceRegistries\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"desiredCount\": \"\",\n  \"taskDefinition\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"networkConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"forceNewDeployment\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"loadBalancers\": \"\",\n  \"propagateTags\": \"\",\n  \"serviceRegistries\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 498

{
  "cluster": "",
  "service": "",
  "desiredCount": "",
  "taskDefinition": "",
  "capacityProviderStrategy": "",
  "deploymentConfiguration": "",
  "networkConfiguration": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "platformVersion": "",
  "forceNewDeployment": "",
  "healthCheckGracePeriodSeconds": "",
  "enableExecuteCommand": "",
  "enableECSManagedTags": "",
  "loadBalancers": "",
  "propagateTags": "",
  "serviceRegistries": "",
  "serviceConnectConfiguration": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"desiredCount\": \"\",\n  \"taskDefinition\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"networkConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"forceNewDeployment\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"loadBalancers\": \"\",\n  \"propagateTags\": \"\",\n  \"serviceRegistries\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"desiredCount\": \"\",\n  \"taskDefinition\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"networkConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"forceNewDeployment\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"loadBalancers\": \"\",\n  \"propagateTags\": \"\",\n  \"serviceRegistries\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"desiredCount\": \"\",\n  \"taskDefinition\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"networkConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"forceNewDeployment\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"loadBalancers\": \"\",\n  \"propagateTags\": \"\",\n  \"serviceRegistries\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"desiredCount\": \"\",\n  \"taskDefinition\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"networkConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"forceNewDeployment\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"loadBalancers\": \"\",\n  \"propagateTags\": \"\",\n  \"serviceRegistries\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  service: '',
  desiredCount: '',
  taskDefinition: '',
  capacityProviderStrategy: '',
  deploymentConfiguration: '',
  networkConfiguration: '',
  placementConstraints: '',
  placementStrategy: '',
  platformVersion: '',
  forceNewDeployment: '',
  healthCheckGracePeriodSeconds: '',
  enableExecuteCommand: '',
  enableECSManagedTags: '',
  loadBalancers: '',
  propagateTags: '',
  serviceRegistries: '',
  serviceConnectConfiguration: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    cluster: '',
    service: '',
    desiredCount: '',
    taskDefinition: '',
    capacityProviderStrategy: '',
    deploymentConfiguration: '',
    networkConfiguration: '',
    placementConstraints: '',
    placementStrategy: '',
    platformVersion: '',
    forceNewDeployment: '',
    healthCheckGracePeriodSeconds: '',
    enableExecuteCommand: '',
    enableECSManagedTags: '',
    loadBalancers: '',
    propagateTags: '',
    serviceRegistries: '',
    serviceConnectConfiguration: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","service":"","desiredCount":"","taskDefinition":"","capacityProviderStrategy":"","deploymentConfiguration":"","networkConfiguration":"","placementConstraints":"","placementStrategy":"","platformVersion":"","forceNewDeployment":"","healthCheckGracePeriodSeconds":"","enableExecuteCommand":"","enableECSManagedTags":"","loadBalancers":"","propagateTags":"","serviceRegistries":"","serviceConnectConfiguration":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "service": "",\n  "desiredCount": "",\n  "taskDefinition": "",\n  "capacityProviderStrategy": "",\n  "deploymentConfiguration": "",\n  "networkConfiguration": "",\n  "placementConstraints": "",\n  "placementStrategy": "",\n  "platformVersion": "",\n  "forceNewDeployment": "",\n  "healthCheckGracePeriodSeconds": "",\n  "enableExecuteCommand": "",\n  "enableECSManagedTags": "",\n  "loadBalancers": "",\n  "propagateTags": "",\n  "serviceRegistries": "",\n  "serviceConnectConfiguration": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"desiredCount\": \"\",\n  \"taskDefinition\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"networkConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"forceNewDeployment\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"loadBalancers\": \"\",\n  \"propagateTags\": \"\",\n  \"serviceRegistries\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  cluster: '',
  service: '',
  desiredCount: '',
  taskDefinition: '',
  capacityProviderStrategy: '',
  deploymentConfiguration: '',
  networkConfiguration: '',
  placementConstraints: '',
  placementStrategy: '',
  platformVersion: '',
  forceNewDeployment: '',
  healthCheckGracePeriodSeconds: '',
  enableExecuteCommand: '',
  enableECSManagedTags: '',
  loadBalancers: '',
  propagateTags: '',
  serviceRegistries: '',
  serviceConnectConfiguration: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    cluster: '',
    service: '',
    desiredCount: '',
    taskDefinition: '',
    capacityProviderStrategy: '',
    deploymentConfiguration: '',
    networkConfiguration: '',
    placementConstraints: '',
    placementStrategy: '',
    platformVersion: '',
    forceNewDeployment: '',
    healthCheckGracePeriodSeconds: '',
    enableExecuteCommand: '',
    enableECSManagedTags: '',
    loadBalancers: '',
    propagateTags: '',
    serviceRegistries: '',
    serviceConnectConfiguration: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  service: '',
  desiredCount: '',
  taskDefinition: '',
  capacityProviderStrategy: '',
  deploymentConfiguration: '',
  networkConfiguration: '',
  placementConstraints: '',
  placementStrategy: '',
  platformVersion: '',
  forceNewDeployment: '',
  healthCheckGracePeriodSeconds: '',
  enableExecuteCommand: '',
  enableECSManagedTags: '',
  loadBalancers: '',
  propagateTags: '',
  serviceRegistries: '',
  serviceConnectConfiguration: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    cluster: '',
    service: '',
    desiredCount: '',
    taskDefinition: '',
    capacityProviderStrategy: '',
    deploymentConfiguration: '',
    networkConfiguration: '',
    placementConstraints: '',
    placementStrategy: '',
    platformVersion: '',
    forceNewDeployment: '',
    healthCheckGracePeriodSeconds: '',
    enableExecuteCommand: '',
    enableECSManagedTags: '',
    loadBalancers: '',
    propagateTags: '',
    serviceRegistries: '',
    serviceConnectConfiguration: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","service":"","desiredCount":"","taskDefinition":"","capacityProviderStrategy":"","deploymentConfiguration":"","networkConfiguration":"","placementConstraints":"","placementStrategy":"","platformVersion":"","forceNewDeployment":"","healthCheckGracePeriodSeconds":"","enableExecuteCommand":"","enableECSManagedTags":"","loadBalancers":"","propagateTags":"","serviceRegistries":"","serviceConnectConfiguration":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"service": @"",
                              @"desiredCount": @"",
                              @"taskDefinition": @"",
                              @"capacityProviderStrategy": @"",
                              @"deploymentConfiguration": @"",
                              @"networkConfiguration": @"",
                              @"placementConstraints": @"",
                              @"placementStrategy": @"",
                              @"platformVersion": @"",
                              @"forceNewDeployment": @"",
                              @"healthCheckGracePeriodSeconds": @"",
                              @"enableExecuteCommand": @"",
                              @"enableECSManagedTags": @"",
                              @"loadBalancers": @"",
                              @"propagateTags": @"",
                              @"serviceRegistries": @"",
                              @"serviceConnectConfiguration": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"desiredCount\": \"\",\n  \"taskDefinition\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"networkConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"forceNewDeployment\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"loadBalancers\": \"\",\n  \"propagateTags\": \"\",\n  \"serviceRegistries\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'service' => '',
    'desiredCount' => '',
    'taskDefinition' => '',
    'capacityProviderStrategy' => '',
    'deploymentConfiguration' => '',
    'networkConfiguration' => '',
    'placementConstraints' => '',
    'placementStrategy' => '',
    'platformVersion' => '',
    'forceNewDeployment' => '',
    'healthCheckGracePeriodSeconds' => '',
    'enableExecuteCommand' => '',
    'enableECSManagedTags' => '',
    'loadBalancers' => '',
    'propagateTags' => '',
    'serviceRegistries' => '',
    'serviceConnectConfiguration' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService', [
  'body' => '{
  "cluster": "",
  "service": "",
  "desiredCount": "",
  "taskDefinition": "",
  "capacityProviderStrategy": "",
  "deploymentConfiguration": "",
  "networkConfiguration": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "platformVersion": "",
  "forceNewDeployment": "",
  "healthCheckGracePeriodSeconds": "",
  "enableExecuteCommand": "",
  "enableECSManagedTags": "",
  "loadBalancers": "",
  "propagateTags": "",
  "serviceRegistries": "",
  "serviceConnectConfiguration": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'service' => '',
  'desiredCount' => '',
  'taskDefinition' => '',
  'capacityProviderStrategy' => '',
  'deploymentConfiguration' => '',
  'networkConfiguration' => '',
  'placementConstraints' => '',
  'placementStrategy' => '',
  'platformVersion' => '',
  'forceNewDeployment' => '',
  'healthCheckGracePeriodSeconds' => '',
  'enableExecuteCommand' => '',
  'enableECSManagedTags' => '',
  'loadBalancers' => '',
  'propagateTags' => '',
  'serviceRegistries' => '',
  'serviceConnectConfiguration' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'service' => '',
  'desiredCount' => '',
  'taskDefinition' => '',
  'capacityProviderStrategy' => '',
  'deploymentConfiguration' => '',
  'networkConfiguration' => '',
  'placementConstraints' => '',
  'placementStrategy' => '',
  'platformVersion' => '',
  'forceNewDeployment' => '',
  'healthCheckGracePeriodSeconds' => '',
  'enableExecuteCommand' => '',
  'enableECSManagedTags' => '',
  'loadBalancers' => '',
  'propagateTags' => '',
  'serviceRegistries' => '',
  'serviceConnectConfiguration' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "service": "",
  "desiredCount": "",
  "taskDefinition": "",
  "capacityProviderStrategy": "",
  "deploymentConfiguration": "",
  "networkConfiguration": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "platformVersion": "",
  "forceNewDeployment": "",
  "healthCheckGracePeriodSeconds": "",
  "enableExecuteCommand": "",
  "enableECSManagedTags": "",
  "loadBalancers": "",
  "propagateTags": "",
  "serviceRegistries": "",
  "serviceConnectConfiguration": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "service": "",
  "desiredCount": "",
  "taskDefinition": "",
  "capacityProviderStrategy": "",
  "deploymentConfiguration": "",
  "networkConfiguration": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "platformVersion": "",
  "forceNewDeployment": "",
  "healthCheckGracePeriodSeconds": "",
  "enableExecuteCommand": "",
  "enableECSManagedTags": "",
  "loadBalancers": "",
  "propagateTags": "",
  "serviceRegistries": "",
  "serviceConnectConfiguration": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"desiredCount\": \"\",\n  \"taskDefinition\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"networkConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"forceNewDeployment\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"loadBalancers\": \"\",\n  \"propagateTags\": \"\",\n  \"serviceRegistries\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService"

payload = {
    "cluster": "",
    "service": "",
    "desiredCount": "",
    "taskDefinition": "",
    "capacityProviderStrategy": "",
    "deploymentConfiguration": "",
    "networkConfiguration": "",
    "placementConstraints": "",
    "placementStrategy": "",
    "platformVersion": "",
    "forceNewDeployment": "",
    "healthCheckGracePeriodSeconds": "",
    "enableExecuteCommand": "",
    "enableECSManagedTags": "",
    "loadBalancers": "",
    "propagateTags": "",
    "serviceRegistries": "",
    "serviceConnectConfiguration": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService"

payload <- "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"desiredCount\": \"\",\n  \"taskDefinition\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"networkConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"forceNewDeployment\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"loadBalancers\": \"\",\n  \"propagateTags\": \"\",\n  \"serviceRegistries\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"desiredCount\": \"\",\n  \"taskDefinition\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"networkConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"forceNewDeployment\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"loadBalancers\": \"\",\n  \"propagateTags\": \"\",\n  \"serviceRegistries\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"desiredCount\": \"\",\n  \"taskDefinition\": \"\",\n  \"capacityProviderStrategy\": \"\",\n  \"deploymentConfiguration\": \"\",\n  \"networkConfiguration\": \"\",\n  \"placementConstraints\": \"\",\n  \"placementStrategy\": \"\",\n  \"platformVersion\": \"\",\n  \"forceNewDeployment\": \"\",\n  \"healthCheckGracePeriodSeconds\": \"\",\n  \"enableExecuteCommand\": \"\",\n  \"enableECSManagedTags\": \"\",\n  \"loadBalancers\": \"\",\n  \"propagateTags\": \"\",\n  \"serviceRegistries\": \"\",\n  \"serviceConnectConfiguration\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService";

    let payload = json!({
        "cluster": "",
        "service": "",
        "desiredCount": "",
        "taskDefinition": "",
        "capacityProviderStrategy": "",
        "deploymentConfiguration": "",
        "networkConfiguration": "",
        "placementConstraints": "",
        "placementStrategy": "",
        "platformVersion": "",
        "forceNewDeployment": "",
        "healthCheckGracePeriodSeconds": "",
        "enableExecuteCommand": "",
        "enableECSManagedTags": "",
        "loadBalancers": "",
        "propagateTags": "",
        "serviceRegistries": "",
        "serviceConnectConfiguration": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "service": "",
  "desiredCount": "",
  "taskDefinition": "",
  "capacityProviderStrategy": "",
  "deploymentConfiguration": "",
  "networkConfiguration": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "platformVersion": "",
  "forceNewDeployment": "",
  "healthCheckGracePeriodSeconds": "",
  "enableExecuteCommand": "",
  "enableECSManagedTags": "",
  "loadBalancers": "",
  "propagateTags": "",
  "serviceRegistries": "",
  "serviceConnectConfiguration": ""
}'

echo '{
  "cluster": "",
  "service": "",
  "desiredCount": "",
  "taskDefinition": "",
  "capacityProviderStrategy": "",
  "deploymentConfiguration": "",
  "networkConfiguration": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "platformVersion": "",
  "forceNewDeployment": "",
  "healthCheckGracePeriodSeconds": "",
  "enableExecuteCommand": "",
  "enableECSManagedTags": "",
  "loadBalancers": "",
  "propagateTags": "",
  "serviceRegistries": "",
  "serviceConnectConfiguration": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "service": "",\n  "desiredCount": "",\n  "taskDefinition": "",\n  "capacityProviderStrategy": "",\n  "deploymentConfiguration": "",\n  "networkConfiguration": "",\n  "placementConstraints": "",\n  "placementStrategy": "",\n  "platformVersion": "",\n  "forceNewDeployment": "",\n  "healthCheckGracePeriodSeconds": "",\n  "enableExecuteCommand": "",\n  "enableECSManagedTags": "",\n  "loadBalancers": "",\n  "propagateTags": "",\n  "serviceRegistries": "",\n  "serviceConnectConfiguration": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "service": "",
  "desiredCount": "",
  "taskDefinition": "",
  "capacityProviderStrategy": "",
  "deploymentConfiguration": "",
  "networkConfiguration": "",
  "placementConstraints": "",
  "placementStrategy": "",
  "platformVersion": "",
  "forceNewDeployment": "",
  "healthCheckGracePeriodSeconds": "",
  "enableExecuteCommand": "",
  "enableECSManagedTags": "",
  "loadBalancers": "",
  "propagateTags": "",
  "serviceRegistries": "",
  "serviceConnectConfiguration": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateService")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{}

POST UpdateServicePrimaryTaskSet

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "service": "",
  "primaryTaskSet": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"primaryTaskSet\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet" {:headers {:x-amz-target ""}
                                                                                                                         :content-type :json
                                                                                                                         :form-params {:cluster ""
                                                                                                                                       :service ""
                                                                                                                                       :primaryTaskSet ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"primaryTaskSet\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"primaryTaskSet\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"primaryTaskSet\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"primaryTaskSet\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 60

{
  "cluster": "",
  "service": "",
  "primaryTaskSet": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"primaryTaskSet\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"primaryTaskSet\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"primaryTaskSet\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"primaryTaskSet\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  service: '',
  primaryTaskSet: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', service: '', primaryTaskSet: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","service":"","primaryTaskSet":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "service": "",\n  "primaryTaskSet": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"primaryTaskSet\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', service: '', primaryTaskSet: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', service: '', primaryTaskSet: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  service: '',
  primaryTaskSet: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', service: '', primaryTaskSet: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","service":"","primaryTaskSet":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"service": @"",
                              @"primaryTaskSet": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"primaryTaskSet\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'service' => '',
    'primaryTaskSet' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet', [
  'body' => '{
  "cluster": "",
  "service": "",
  "primaryTaskSet": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'service' => '',
  'primaryTaskSet' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'service' => '',
  'primaryTaskSet' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "service": "",
  "primaryTaskSet": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "service": "",
  "primaryTaskSet": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"primaryTaskSet\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet"

payload = {
    "cluster": "",
    "service": "",
    "primaryTaskSet": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet"

payload <- "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"primaryTaskSet\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"primaryTaskSet\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"primaryTaskSet\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet";

    let payload = json!({
        "cluster": "",
        "service": "",
        "primaryTaskSet": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "service": "",
  "primaryTaskSet": ""
}'

echo '{
  "cluster": "",
  "service": "",
  "primaryTaskSet": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "service": "",\n  "primaryTaskSet": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "service": "",
  "primaryTaskSet": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateTaskProtection

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "tasks": "",
  "protectionEnabled": "",
  "expiresInMinutes": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"protectionEnabled\": \"\",\n  \"expiresInMinutes\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection" {:headers {:x-amz-target ""}
                                                                                                                  :content-type :json
                                                                                                                  :form-params {:cluster ""
                                                                                                                                :tasks ""
                                                                                                                                :protectionEnabled ""
                                                                                                                                :expiresInMinutes ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"protectionEnabled\": \"\",\n  \"expiresInMinutes\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"protectionEnabled\": \"\",\n  \"expiresInMinutes\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"protectionEnabled\": \"\",\n  \"expiresInMinutes\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"protectionEnabled\": \"\",\n  \"expiresInMinutes\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 87

{
  "cluster": "",
  "tasks": "",
  "protectionEnabled": "",
  "expiresInMinutes": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"protectionEnabled\": \"\",\n  \"expiresInMinutes\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"protectionEnabled\": \"\",\n  \"expiresInMinutes\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"protectionEnabled\": \"\",\n  \"expiresInMinutes\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"protectionEnabled\": \"\",\n  \"expiresInMinutes\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  tasks: '',
  protectionEnabled: '',
  expiresInMinutes: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', tasks: '', protectionEnabled: '', expiresInMinutes: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","tasks":"","protectionEnabled":"","expiresInMinutes":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "tasks": "",\n  "protectionEnabled": "",\n  "expiresInMinutes": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"protectionEnabled\": \"\",\n  \"expiresInMinutes\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', tasks: '', protectionEnabled: '', expiresInMinutes: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', tasks: '', protectionEnabled: '', expiresInMinutes: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  tasks: '',
  protectionEnabled: '',
  expiresInMinutes: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', tasks: '', protectionEnabled: '', expiresInMinutes: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","tasks":"","protectionEnabled":"","expiresInMinutes":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"tasks": @"",
                              @"protectionEnabled": @"",
                              @"expiresInMinutes": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"protectionEnabled\": \"\",\n  \"expiresInMinutes\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'tasks' => '',
    'protectionEnabled' => '',
    'expiresInMinutes' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection', [
  'body' => '{
  "cluster": "",
  "tasks": "",
  "protectionEnabled": "",
  "expiresInMinutes": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'tasks' => '',
  'protectionEnabled' => '',
  'expiresInMinutes' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'tasks' => '',
  'protectionEnabled' => '',
  'expiresInMinutes' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "tasks": "",
  "protectionEnabled": "",
  "expiresInMinutes": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "tasks": "",
  "protectionEnabled": "",
  "expiresInMinutes": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"protectionEnabled\": \"\",\n  \"expiresInMinutes\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection"

payload = {
    "cluster": "",
    "tasks": "",
    "protectionEnabled": "",
    "expiresInMinutes": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection"

payload <- "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"protectionEnabled\": \"\",\n  \"expiresInMinutes\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"protectionEnabled\": \"\",\n  \"expiresInMinutes\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"tasks\": \"\",\n  \"protectionEnabled\": \"\",\n  \"expiresInMinutes\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection";

    let payload = json!({
        "cluster": "",
        "tasks": "",
        "protectionEnabled": "",
        "expiresInMinutes": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "tasks": "",
  "protectionEnabled": "",
  "expiresInMinutes": ""
}'

echo '{
  "cluster": "",
  "tasks": "",
  "protectionEnabled": "",
  "expiresInMinutes": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "tasks": "",\n  "protectionEnabled": "",\n  "expiresInMinutes": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "tasks": "",
  "protectionEnabled": "",
  "expiresInMinutes": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskProtection")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "failures": [],
  "protectedTasks": [
    {
      "protectionEnabled": false,
      "taskArn": "arn:aws:ecs:us-west-2:012345678910:task/b8b1cf532d0e46ba8d44a40d1de16772"
    }
  ]
}

POST UpdateTaskSet

{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet

HEADERS

X-Amz-Target

BODY json

{
  "cluster": "",
  "service": "",
  "taskSet": "",
  "scale": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"scale\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:cluster ""
                                                                                                                         :service ""
                                                                                                                         :taskSet ""
                                                                                                                         :scale ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"scale\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"scale\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"scale\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet"

	payload := strings.NewReader("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"scale\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 68

{
  "cluster": "",
  "service": "",
  "taskSet": "",
  "scale": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"scale\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"scale\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"scale\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"scale\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cluster: '',
  service: '',
  taskSet: '',
  scale: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', service: '', taskSet: '', scale: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","service":"","taskSet":"","scale":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cluster": "",\n  "service": "",\n  "taskSet": "",\n  "scale": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"scale\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({cluster: '', service: '', taskSet: '', scale: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {cluster: '', service: '', taskSet: '', scale: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cluster: '',
  service: '',
  taskSet: '',
  scale: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {cluster: '', service: '', taskSet: '', scale: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"cluster":"","service":"","taskSet":"","scale":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cluster": @"",
                              @"service": @"",
                              @"taskSet": @"",
                              @"scale": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"scale\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'cluster' => '',
    'service' => '',
    'taskSet' => '',
    'scale' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet', [
  'body' => '{
  "cluster": "",
  "service": "",
  "taskSet": "",
  "scale": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cluster' => '',
  'service' => '',
  'taskSet' => '',
  'scale' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cluster' => '',
  'service' => '',
  'taskSet' => '',
  'scale' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "service": "",
  "taskSet": "",
  "scale": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cluster": "",
  "service": "",
  "taskSet": "",
  "scale": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"scale\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet"

payload = {
    "cluster": "",
    "service": "",
    "taskSet": "",
    "scale": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet"

payload <- "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"scale\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"scale\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"cluster\": \"\",\n  \"service\": \"\",\n  \"taskSet\": \"\",\n  \"scale\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet";

    let payload = json!({
        "cluster": "",
        "service": "",
        "taskSet": "",
        "scale": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "cluster": "",
  "service": "",
  "taskSet": "",
  "scale": ""
}'

echo '{
  "cluster": "",
  "service": "",
  "taskSet": "",
  "scale": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cluster": "",\n  "service": "",\n  "taskSet": "",\n  "scale": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "cluster": "",
  "service": "",
  "taskSet": "",
  "scale": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonEC2ContainerServiceV20141113.UpdateTaskSet")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()