v1.9.3

pkg/cloudbroker/prometheus/compute_cpu_load.go

@@ -0,0 +1,57 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
+)
+
+type ComputeCPULoadRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: true
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+
+	// Number of zeros after the decimal point
+	// Required: true
+	DecimalPlaces uint64 `url:"decimalPlaces,omitempty" json:"decimalPlaces,omitempty"`
+}
+
+// Per-second CPU time consumed by Compute in percent, average over the time step specified
+func (p Prometheus) ComputeCPULoad(ctx context.Context, req ComputeCPULoadRequest) (*PrometheusData, error) {
+	res, err := p.ComputeCPULoadRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeCPULoadRaw(ctx context.Context, req ComputeCPULoadRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/prometheus/computeCPUload"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudbroker/prometheus/compute_memory_available.go

@@ -0,0 +1,53 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
+)
+
+type ComputeMemoryAvailableRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: true
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+}
+
+// Available Memory
+func (p Prometheus) ComputeMemoryAvailable(ctx context.Context, req ComputeMemoryAvailableRequest) (*PrometheusData, error) {
+	res, err := p.ComputeMemoryAvailableRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeMemoryAvailableRaw(ctx context.Context, req ComputeMemoryAvailableRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/prometheus/computeMemoryAvailable"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudbroker/prometheus/compute_memory_unused.go

@@ -0,0 +1,53 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
+)
+
+type ComputeMemoryUnusedRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: true
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+}
+
+// Unused Memory
+func (p Prometheus) ComputeMemoryUnused(ctx context.Context, req ComputeMemoryUnusedRequest) (*PrometheusData, error) {
+	res, err := p.ComputeMemoryUnusedRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeMemoryUnusedRaw(ctx context.Context, req ComputeMemoryUnusedRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/prometheus/computeMemoryUnused"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudbroker/prometheus/compute_memory_usable.go

@@ -0,0 +1,53 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
+)
+
+type ComputeMemoryUsableRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: true
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+}
+
+// Usable Memory
+func (p Prometheus) ComputeMemoryUsable(ctx context.Context, req ComputeMemoryUsableRequest) (*PrometheusData, error) {
+	res, err := p.ComputeMemoryUsableRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeMemoryUsableRaw(ctx context.Context, req ComputeMemoryUsableRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/prometheus/computeMemoryUsable"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudbroker/prometheus/compute_memory_usage.go

@@ -0,0 +1,53 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
+)
+
+type ComputeMemoryUsageRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: true
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+}
+
+// Memory Usage
+func (p Prometheus) ComputeMemoryUsage(ctx context.Context, req ComputeMemoryUsageRequest) (*PrometheusData, error) {
+	res, err := p.ComputeMemoryUsageRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeMemoryUsageRaw(ctx context.Context, req ComputeMemoryUsageRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/prometheus/computeMemoryUsage"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudbroker/prometheus/compute_memory_used.go

@@ -0,0 +1,53 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
+)
+
+type ComputeMemoryUsedRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: true
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+}
+
+// Used Memory
+func (p Prometheus) ComputeMemoryUsed(ctx context.Context, req ComputeMemoryUsedRequest) (*PrometheusData, error) {
+	res, err := p.ComputeMemoryUsedRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeMemoryUsedRaw(ctx context.Context, req ComputeMemoryUsedRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/prometheus/computeMemoryUsed"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudbroker/prometheus/compute_read_bytes.go

@@ -0,0 +1,57 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
+)
+
+type ComputeReadBytesRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: true
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+
+	// Number of zeros after the decimal point
+	// Required: true
+	DecimalPlaces uint64 `url:"decimalPlaces,omitempty" json:"decimalPlaces,omitempty"`
+}
+
+// Read Bytes
+func (p Prometheus) ComputeReadBytes(ctx context.Context, req ComputeReadBytesRequest) (*PrometheusData, error) {
+	res, err := p.ComputeReadBytesRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeReadBytesRaw(ctx context.Context, req ComputeReadBytesRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/prometheus/computeReadBytes"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudbroker/prometheus/compute_read_requests.go

@@ -0,0 +1,57 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
+)
+
+type ComputeReadRequestsRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: true
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+
+	// Number of zeros after the decimal point
+	// Required: true
+	DecimalPlaces uint64 `url:"decimalPlaces,omitempty" json:"decimalPlaces,omitempty"`
+}
+
+// Read Requests
+func (p Prometheus) ComputeReadRequests(ctx context.Context, req ComputeReadRequestsRequest) (*PrometheusData, error) {
+	res, err := p.ComputeReadRequestsRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeReadRequestsRaw(ctx context.Context, req ComputeReadRequestsRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/prometheus/computeReadRequests"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudbroker/prometheus/compute_receive_bytes.go

@@ -0,0 +1,57 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
+)
+
+type ComputeReceiveBytesRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: true
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+
+	// Number of zeros after the decimal point
+	// Required: true
+	DecimalPlaces uint64 `url:"decimalPlaces,omitempty" json:"decimalPlaces,omitempty"`
+}
+
+// Receive Bytes
+func (p Prometheus) ComputeReceiveBytes(ctx context.Context, req ComputeReceiveBytesRequest) (*PrometheusData, error) {
+	res, err := p.ComputeReceiveBytesRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeReceiveBytesRaw(ctx context.Context, req ComputeReceiveBytesRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/prometheus/computeReceiveBytes"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudbroker/prometheus/compute_receive_packets.go

@@ -0,0 +1,57 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
+)
+
+type ComputeReceivePacketsRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: true
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+
+	// Number of zeros after the decimal point
+	// Required: true
+	DecimalPlaces uint64 `url:"decimalPlaces,omitempty" json:"decimalPlaces,omitempty"`
+}
+
+// Receive Packets
+func (p Prometheus) ComputeReceivePackets(ctx context.Context, req ComputeReceivePacketsRequest) (*PrometheusData, error) {
+	res, err := p.ComputeReceivePacketsRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeReceivePacketsRaw(ctx context.Context, req ComputeReceivePacketsRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/prometheus/computeReceivePackets"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudbroker/prometheus/compute_transmit_bytes.go

@@ -0,0 +1,57 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
+)
+
+type ComputeTransmitBytesRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: true
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+
+	// Number of zeros after the decimal point
+	// Required: true
+	DecimalPlaces uint64 `url:"decimalPlaces,omitempty" json:"decimalPlaces,omitempty"`
+}
+
+// Transmit Bytes
+func (p Prometheus) ComputeTransmitBytes(ctx context.Context, req ComputeTransmitBytesRequest) (*PrometheusData, error) {
+	res, err := p.ComputeTransmitBytesRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeTransmitBytesRaw(ctx context.Context, req ComputeTransmitBytesRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/prometheus/computeTransmitBytes"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudbroker/prometheus/compute_transmit_packets.go

@@ -0,0 +1,57 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
+)
+
+type ComputeTransmitPacketsRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: true
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+
+	// Number of zeros after the decimal point
+	// Required: true
+	DecimalPlaces uint64 `url:"decimalPlaces,omitempty" json:"decimalPlaces,omitempty"`
+}
+
+// Transmit Packets
+func (p Prometheus) ComputeTransmitPackets(ctx context.Context, req ComputeTransmitPacketsRequest) (*PrometheusData, error) {
+	res, err := p.ComputeTransmitPacketsRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeTransmitPacketsRaw(ctx context.Context, req ComputeTransmitPacketsRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/prometheus/computeTransmitPackets"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudbroker/prometheus/compute_write_bytes.go

@@ -0,0 +1,57 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
+)
+
+type ComputeWriteBytesRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: true
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+
+	// Number of zeros after the decimal point
+	// Required: true
+	DecimalPlaces uint64 `url:"decimalPlaces,omitempty" json:"decimalPlaces,omitempty"`
+}
+
+// Write Bytes
+func (p Prometheus) ComputeWriteBytes(ctx context.Context, req ComputeWriteBytesRequest) (*PrometheusData, error) {
+	res, err := p.ComputeWriteBytesRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeWriteBytesRaw(ctx context.Context, req ComputeWriteBytesRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/prometheus/computeWriteBytes"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudbroker/prometheus/compute_write_requests.go

@@ -0,0 +1,57 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
+)
+
+type ComputeWriteRequestsRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: true
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+
+	// Number of zeros after the decimal point
+	// Required: true
+	DecimalPlaces uint64 `url:"decimalPlaces,omitempty" json:"decimalPlaces,omitempty"`
+}
+
+// Write Requests
+func (p Prometheus) ComputeWriteRequests(ctx context.Context, req ComputeWriteRequestsRequest) (*PrometheusData, error) {
+	res, err := p.ComputeWriteRequestsRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeWriteRequestsRaw(ctx context.Context, req ComputeWriteRequestsRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/prometheus/computeWriteRequests"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudbroker/prometheus/models.go

@@ -0,0 +1,13 @@
+package prometheus
+
+// PrometheusData represents an array of data points
+type PrometheusData []PrometheusPoint
+
+// PrometheusPoint represents a single data point
+type PrometheusPoint struct {
+	// Value of the metric at a specific point in time
+	Value float64 `json:"value"`
+
+	// Timestamp the Unix timestamp.
+	Timestamp uint64 `json:"timestamp"`
+}

pkg/cloudbroker/prometheus/prometheus.go

@@ -0,0 +1,17 @@
+package prometheus
+
+import (
+	"repository.basistech.ru/BASIS/decort-golang-sdk/interfaces"
+)
+
+// Structure for creating request to prometheus
+type Prometheus struct {
+	client interfaces.Caller
+}
+
+// Builder for prometheus endpoints
+func New(client interfaces.Caller) *Prometheus {
+	return &Prometheus{
+		client: client,
+	}
+}