# US 10,521,284 B2 · System and method for management of deployed services and applications

> Agents: this data is available as JSON from the patentgrep API and MCP server — see https://patentgrep.com/llms.txt

- Number: US 10,521,284 B2
- Document ID: US10521284B2
- Status: Granted
- Kind: B2
- Application number: 15/695,988
- Filed: 2017-09-05
- Published: 2018-11-08
- Granted: 2019-12-31
- Earliest claimed: 2017-05-08
- Assignees: Datapipe, Inc.
- Applicants: Datapipe, Inc.
- Inventors: Thomas Patrick McClory; Jatil Chandrakant Damania; Scott Matthew Vidmar
- Web page: https://patentgrep.com/patent/US10521284B2

## CPC

- G06F 9/546: {Message passing systems or structures, e.g. queues}
- G06F 8/30: Creation or generation of source code
- G06F 8/41: Compilation
- G06F 8/60: Software deployment
- G06F 8/71: Version control (security arrangements therefor G06F21/57); Configuration management
- G06F 9/45558: {Hypervisor-specific management and integration aspects}
- G06F 9/5027: {the resource being a machine, e.g. CPUs, Servers, Terminals}
- G06F 9/505: {considering the load}
- G06F 11/3684: {for test design, e.g. generating new test cases}
- G06F 11/3688: {for test execution, e.g. scheduling of test suites}
- G06Q 10/06398: {Performance of employee with respect to a job function}
- H04L 41/5041: characterised by the time relationship between creation and deployment of a service
- H04L 41/5054: Automatic deployment of services triggered by the service manager, e.g. service implementation by automatic configuration of network components
- H04L 63/0236: {Filtering by address, protocol, port number or service, e.g. IP-address or URL}
- H04L 63/0281: {Proxies}
- G06F 8/77: Software metrics
- G06F 16/24: Querying
- G06F 2009/45583: {Memory management, e.g. access or allocation}
- G06F 2009/45587: {Isolation or security of virtual machine instances}
- G06F 2009/45591: {Monitoring or debugging support}
- G06F 2209/501: Performance criteria
- G06F 2209/541: Client-server
- G06F 2209/548: Queue
- H04L 41/5083: {wherein the managed service relates to web hosting}
- H04L 63/1433: {Vulnerability analysis}
- H04L 67/10: in which an application is distributed across nodes in the network (software deployment G06F8/60; multiprogramming arrangements G06F9/46)
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)
- G06Q: INFORMATION AND COMMUNICATION TECHNOLOGY [ICT] SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES; SYSTEMS OR METHODS SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES, NOT OTHERWISE PROVIDED FOR
- H04L: TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION (arrangements common to telegraphic and telephonic communication H04M)

## Abstract

Disclosed herein are system, apparatus, article of manufacture, method and/or computer program product embodiments, and/or combinations and sub-combinations thereof, for processing requests for a deployed service or application. According to an embodiment, a request for a service may be received by a command application programming interface (API) from a client device. A request identifier and a task message specifying a task to be performed by the service may be generated based on the received request. A read cache may be updated with the request identifier, and the task message may be transmitted to a command task queue. A worker process may detect the task message upon transmission of the task message to the command queue and execute the task specified by the task message. Upon completion of the task, a completion message may be transmitted to an event publish queue.

## Claims

### Claim 1

A system for management of a deployment, the system comprising:
at least one processor; and
a memory operatively coupled to the at least one processor, the at least one processor configured at least in part to:
receive, by a command application programming interface (API) of a service, a request for the service from a client device;
generate, by the command API, a task message and a request identifier based on the request, the task message specifying a task to be performed by the service;
update, by the command API, a read cache, accessible by a worker process and by the command API, to include the request identifier;
transmit, by the command API, the task message to a command task queue;
detect, by the worker process of the service, the task message upon transmission of the task message to the command task queue;
receive, by a stream listener of the service, a published message from an event stream, wherein the event stream comprises communication across a plurality of related services, applications, or a combination thereof, wherein the stream listener is configured to subscribe to the event stream, and wherein multiple instances of the command API, worker process, or stream listener are configured for parallel execution and load balancing;
apply, by the stream listener, one or more filtering rules to the published message to determine whether the published message is relevant to the service;
execute, by the worker process, the task specified by the task message; and
transmit, by the worker process, a completion message to an event publish queue upon completion of the task specified by the task message.

### Claim 2 (depends on 1)

The system of claim 1, wherein the at least one processor is further configured to:
periodically transmit, by the worker process, a status of the task specified by the task message to a read queue;
receive, by a read API, a status request including the request identifier from the client device;
retrieve, by the read API, the status from the read queue in response to receiving the status request; and
transmit, by the read API, the status to the client device.

### Claim 3 (depends on 1)

The system of claim 1, wherein the at least one processor is further configured to:
receive, by a read API, a request for data provided by the service;
validate, by the read API, credentials associated with the request for data to determine whether the request for data is authorized to access the requested data;
verify, by the read API, that a request format of the request for data meets one or more predefined format requirements;
retrieve, by the read API, the requested data from the read cache;
retrieve, by the read API, the requested data from a service data store associated with the service when the requested data does not reside in the read cache;
format, by the read API, the requested data according to a service contract associated with the service and the client device; and
transmit, by the read API, the requested data to the client device.

### Claim 4 (depends on 3)

The system of claim 3, wherein the at least one processor is further configured to:
transmit, by the read API, an update message to the command task queue when the requested data does not reside in the read cache, wherein the update message specifies an update task to refresh the read cache with the requested data;
detect, by the worker process, the update message upon transmission of the update message to the command task queue; and
execute, by the worker process, the update task specified by the update message to refresh the read cache with the requested data.

### Claim 5 (depends on 1)

The system of claim 1, wherein, to execute the task specified by the task message, the at least one processor is further configured to:
retrieve, by the worker process, cached data associated with the task specified by the task message from a service data cache, wherein the service data cache stores data reusable by the service for a plurality of service requests; and
update, by the worker process, the service data cache upon completion of the task specified by the task message.

### Claim 6 (depends on 1)

The system of claim 1, wherein, to execute the task specified by the task message, the at least one processor is further configured to:
determine, by the worker process, task data required to perform the task specified by the task message;
retrieve, by the worker process, the task data from a service data store associated with the service;
execute, by the worker process, one or more predefined instructions upon the retrieved data to generate task result data; and
update, by the worker process, the read cache with the task result data for access by the client device.

### Claim 7 (depends on 1)

The system of claim 1, wherein the at least one processor is further configured to:
retrieve, by a stream publisher, a message from the event publish queue;
apply, by the stream publisher, one or more transformation rules to the message to produce a transformed message; and
publish, by the stream publisher, the transformed message to the event stream.

### Claim 8 (depends on 1)

The system of claim 1, wherein the at least one processor is further configured to:
determine, by the stream listener, whether the published message requires the task to be performed by the service; and
transmit, by the stream listener, the published message to the command task queue in response to determining that the published message requires the task to be performed by the service.

### Claim 9 (depends on 1)

The system of claim 1, wherein the request is routed via an API gateway to the command API.

### Claim 10

A computer-implemented method for managing a deployment, the method comprising:
receiving, by a command application programming interface (API) of a service, a request for the service from a client device;
generating a task message and a request identifier based on the request, the task message specifying a task to be performed by the service;
updating a read cache, accessible by a worker process and by the command API, to include the request identifier;
transmitting the task message to a command task queue of the service;
detecting, by the worker process of the service, the task message upon transmission of the task message to the command task queue of the service;
receiving, by a stream listener of the service, a published message from an event stream, wherein the event stream comprises communication across a plurality of related services, applications, or a combination thereof, wherein the stream listener is configured to subscribe to the event stream, and wherein multiple instances of the command API, worker process, or stream listener are configured for parallel execution and load balancing;
applying, by the stream listener, one or more filtering rules to the published message to determine whether the published message is relevant to the service;
executing the task specified by the task message; and
transmitting a completion message to an event publish queue upon completion of the task specified by the task message.

### Claim 11 (depends on 10)

The method of claim 10, further comprising:
periodically transmitting a status of the task specified by the task message to a read queue;
receiving, by a read API, a status request including the request identifier from the client device;
retrieving the status from the read queue in response to receiving the status request; and
transmitting the status to the client device.

### Claim 12 (depends on 10)

The method of claim 10, further comprising:
receiving, by a read API, a request for data provided by the service;
validating credentials associated with the request for data to determine whether the request for data is authorized to access the requested data;
verifying that a request format of the request for data meets one or more predefined format requirements;
retrieving the requested data from the read cache;
retrieving the requested data from a service data store associated with the service when the requested data does not reside in the read cache;
formatting the requested data according to a service contract associated with the service: and
transmitting the requested data to the client device.

### Claim 13 (depends on 12)

The method of claim 12, further comprising:
transmitting an update message to the command task queue when the requested data does not reside in the read cache, wherein the update message specifies an update task to refresh the read cache with the requested data;
detecting, by the worker process, the update message upon transmission of the update message to the command task queue; and
executing the update task specified by the update message to refresh the read cache with the requested data.

### Claim 14 (depends on 10)

The method of claim 10, wherein executing the task specified by the task message further comprises:
retrieving cached data associated with the task specified by the task message from a service data cache, wherein the service data cache stores data reusable by the service for a plurality of service requests; and
updating the service data cache upon completion of the task specified by the task message.

### Claim 15 (depends on 10)

The method of claim 10, wherein executing the task specified by the task message further comprises:
determining task data required to perform the task specified by the task message;
retrieving the task data from a service data store associated with the service;
executing one or more predefined instructions upon the retrieved data to generate task result data; and
updating the read cache with the task result data for access by the client device.

### Claim 16 (depends on 10)

The method of claim 10, further comprising;
retrieving, by a stream publisher, a message from the event publish queue;
applying one or more transformation rules to the message to produce a transformed message; and
publishing the transformed message to the event stream.

### Claim 17 (depends on 10)

The method of claim 10, further comprising:
determining whether the published message requires the task to be performed by the service; and
transmitting the published message to the command task queue in response to determining that the published message requires the task to be performed by the service.

### Claim 18 (depends on 10)

The method of claim 10, wherein the request is routed via an API gateway to the command API.

### Claim 19

A non-transitory tangible computer-readable storage device having instructions stored thereon that, when executed by at least one processor, cause the at least one processor to perform operations to manage a deployment, the operations comprising:
receiving, by a command application programming interface (API) of a service, a request for the service from a client device;
generating a task message and a request identifier based on the request, the task message specifying a task to be performed by the service;
updating a read cache, accessible by a worker process and by the command API, to include the request identifier;
transmitting the task message to a command task queue of the service;
detecting, by a worker process of the service, the task message upon transmission of the task message to the command task queue;
receiving a published message from an event stream, by a stream listener of the service, wherein the event stream comprises communication across a plurality of related services, applications, or a combination thereof, wherein the stream listener is configured to subscribe to the event stream, and wherein multiple instances of the command API, worker process, or stream listener are configured for parallel execution and load balancing;
applying one or more filtering rules to the published message to determine whether the published message is relevant to the service;
executing the task specified by the task message; and
transmitting a completion message to an event publish queue upon completion of the task specified by the task message.

### Claim 20 (depends on 19)

The non-transitory computer-readable storage device of claim 19, the operations further comprising:
receiving, by a read API, a request for data provided by the service;
validating credentials associated with the request for data to determine whether the request is authorized to access the requested data;
verifying that a request format of the request for data meets one or more predefined format requirements;
retrieving the requested data from the read cache;
retrieving the requested data from a service data store associated with the service when the requested data does not reside in the read cache;
formatting the requested data according to a service contract associated with the service; and
transmitting the requested data to the client device.