Technology for building and validating database software in a shared management environment

Abstract

Techniques for building, validating, and utilizing custom database software in a shared management environment are described. A database customization service allows a user to provide database installation files as part of a configuration to generate a custom database engine version. The creation of custom database engine versions can be governed by policy, and the database customization service can provide recommendations for creating custom database engine versions based on various criteria. The custom database engine versions can be built and validated for functionality and correctness. Users can use these custom database engine versions to launch database instances, which can be managed under a shared management scheme where both the user and the database customization service can perform host-level management.

Description

Background Art

[0001] Many companies and other organizations operate computer networks that interconnect numerous computing systems to support their operations, such as where the computing systems are co-located (e.g., as part of a local network) or alternatively located in multiple different geographic locations (e.g., connected via one or more private or public intermediate networks). For example, data centers that house large numbers of interconnected computing systems have become commonplace, such as private data centers operated by and on behalf of a single organization, and public data centers operated by entities that are businesses to provide computing resources to customers. Some public data center operators provide network access, power, and secure installation facilities for hardware owned by various customers, while other public data center operators provide "full service" facilities that also include hardware resources available for use by their customers.

[0002] Many public data center operators (such as service providers that operate service provider networks) provide various computing-related resources as services to their customers. For example, one popular set of services involves databases, where customers can utilize various types of databases, such as relational databases typically used for transactional applications, non-relational databases for Internet-scale applications, data warehouses for analytical tasks, in-memory data stores for caching and / or real-time workloads, graph databases for building applications with highly connected data, time series databases for measuring changes over time, ledger databases for maintaining a complete and verifiable record of transactions, and the like.

[0003] Relational databases, which model data as rows and columns in a series of tables, have long been a popular form of data organization and storage. However, service provider networks and other applications have made it increasingly easy for developers to use a wide variety of other types of data stores in their software applications and systems. Examples of such alternative data store types include object storage services (which can store files of virtually any file type and format), non-relational databases, data warehouses, and so on. While specific relational databases may provide the best storage and query performance in some scenarios, the characteristics of other such data stores (and even types / implementations of relational databases) can improve scalability and performance for other use cases. The ability to easily integrate different types of data stores into software applications and systems has led to the increasing use of multiple types of data stores, depending on the specific performance, durability, availability, scalability, security, and other considerations associated with each subset of data to be stored and used by the application. BRIEF DESCRIPTION OF THE DRAWINGS

[0004] Various embodiments according to the present disclosure will now be described with reference to the accompanying drawings, in which:

[0005] Figure 1 is a diagram illustrating an environment for building, validating, and utilizing custom database software in a shared management environment of a cloud provider network, according to some embodiments.

[0006] Figure 2 is a diagram illustrating an exemplary database installation file, a custom engine version manifest, and a set of database patches for building custom database software in a shared management environment of a cloud provider network, according to some embodiments.

[0007] Figure 3 is a diagram illustrating an exemplary graphical user interface that may be used for custom database engine creation according to some embodiments.

[0008] Figure 4 is a diagram illustrating an environment for utilizing a customized engine version of database software in a shared management environment according to some embodiments.

[0009] Figure 5 is a diagram illustrating aspects of a database customization service for building and validating custom database software according to some embodiments.

[0010] Figure 6 is a diagram illustrating an exemplary graphical user interface for obtaining user-configured build and run policies for CDEV management according to some embodiments.

[0011] Figure 7 is a diagram illustrating a compliance engine and a recommendation engine of a database customization service according to some embodiments.

[0012] Figure 8 is a diagram illustrating exemplary types of information utilized by a compliance engine and / or recommendation engine of a database customization service according to some embodiments.

[0013] Fig. 9 is a diagram illustrating an exemplary graphical user interface including recommendations during custom database engine creation according to some embodiments.

[0014] Fig.10 is a flow chart illustrating the operation of a method for building, validating, and utilizing custom database software according to some embodiments.

[0015] Fig.11 is a flow diagram illustrating the operations of a method for implementing policy controls for building, validating, and utilizing custom database software, according to some embodiments.

[0016] Fig.12is a flow diagram illustrating the operation of a method for generating recommendations for building, validating, and utilizing custom database software, according to some embodiments.

[0017] Fig.13 An example provider network environment is shown according to some embodiments.

[0018] Fig.14 is a block diagram of an example provider network that provides storage services and hardware virtualization services to customers according to some embodiments.

[0019] Fig.15 is a block diagram illustrating an example computer system that may be used in some embodiments. DETAILED DESCRIPTION

[0020] The present disclosure relates to methods, devices, systems, and non-transitory computer-readable storage media for building, validating, and utilizing custom database software in a shared management environment. According to some embodiments, a database customization service is implemented in conjunction with a managed database service, thereby allowing users to customize the database, underlying operating system (OS), and supporting infrastructure they wish to use, while continuing to allow the managed database service to provide a managed database experience by setting up, monitoring, and maintaining these databases and associated resources. Therefore, the database customization service provides a strong compromise between self-managed products (where users deploy their own databases on cloud-managed virtual machines (VMs)) and fully managed products (where users have no ability to customize or manage their underlying database resources).

[0021] A fully managed database service typically takes care of most or all administrative tasks within its users' databases. For example, a managed database service can manage software patches, perform backups, implement automatic failure detection, recovery, and many other operations on behalf of its users.

[0022] To achieve a "managed" service experience, managed database services typically do not allow users to access the underlying host (e.g., the virtual machine and / or physical machine executing the database server application), and may also restrict access to some programs and objects provided by the database that require advanced permissions. Therefore, managed database services typically prohibit their users from directly accessing the operating system hosting the database and / or many configuration settings of the database itself to ensure that the database instance remains in a secure, known state.

[0023] However, for some applications, users may need to perform operations as a privileged OS user. For example, users may want to install custom database and / or OS patches and packages, configure specific database settings, configure the file system to share files directly with their applications, and deploy a database version that is not supported (or no longer supported) by the managed database service.

[0024] Typically, users with these specialized needs must therefore resort to using other computing services / resources to meet their needs, such as "self-hosting" the database by using a virtual machine (or other computing environment) provided by a hardware virtualization service, self-hosting the database in the user's own internal environment or data center, etc. However, this requires the user to have a lot of expertise, time and resources available, because the user will be responsible for database management tasks such as operating system installation, database software installation, implementing scaling capabilities, ensuring high availability, performing database backups, database software patching, operating system patching, and possibly (such as in a self-hosting scenario) server maintenance, hardware lifecycle management, and implementation and management of power, network and cooling systems.

[0025] Additionally, when users manage their database software on their own, while they gain more control, their systems are more susceptible to failures and vulnerabilities due to user error. For example, when users make changes manually, they can accidentally cause application downtime. Additionally, users can spend hours reviewing each change to identify and fix problems as they arise.

[0026] To this end, embodiments disclosed herein provide a managed database service that not only automates common database administration (DBA) tasks, but also supports privileged access to the database and underlying OS. In some embodiments, the managed database service can assume full responsibility for some tasks (e.g., server maintenance, hardware lifecycle management, and implementation and management of power, network, and cooling systems), while providing a "shared" model that allows sharing of responsibility for other tasks (between users and the service), such as application optimization, scaling, high availability, database backup, database software patching and / or installation, OS patching and / or installation, etc.

[0027] Thus, in some embodiments, users can automate management tasks such as managing the lifecycle management of databases, including backups and high availability configuration; monitoring the health of these custom database instances and watching for changes to the infrastructure, OS, and database; and implementing notifications on problems (or taking action) based on corruption of database instances. However, users may also be able to install third-party applications (e.g., custom applications and agents), install custom patches (e.g., custom database patches, small patches, modified OS packages), install unsupported database versions that are not natively supported by the managed database service, stage internal databases before moving them to a fully managed service, create custom automation (e.g., create, schedule, and execute custom automation scripts for reporting, management, or diagnostic tools), and the like.

[0028] For example, embodiments disclosed herein allow users to access the underlying host of a database instance so that the OS and database binaries can be customized, and provide superuser privileges for debugging OS or database problems. When requesting and granting host access, the instance may still be monitored by the managed database service, but some management features may be suspended, such as recovery actions or management tasks such as backup. This allows users to patch their OS or database, or perform other customizations to their database instance that may conflict with recovery actions or running tasks. User access to the host can be provided by a separate system manager component, which audits and records all commands issued by the user. Once host-level access is abandoned, the system can be verified to ensure that it is still in a valid state to run the database instance, and recovery actions and management tasks can be re-enabled thereafter. Any problems caused by the user's modification can be notified to the user, and system protection measures may attempt to repair any influential problems, and the user can be notified of the actions that the customer needs to take. In some embodiments, the user can alternatively directly access the host, for example, via a connection such as a secure shell (SSH) connection.

[0029] For further details, Figure 1 is a diagram illustrating an environment for building, validating, and utilizing custom database software in a shared management environment of a cloud provider network, according to some embodiments. Figure 1In some embodiments, the database customization service 108 allows a user (e.g., user 102) to build and / or utilize a customized engine version 112A that can be used to launch a database instance 114 that can be executed by a managed database service 110 of a provider network (or by other entities at other locations, such as within the user's internal network, in a third-party data center or provider network, etc.). In some embodiments, the managed database service 110 can run these "custom" database instances 114 created or defined by the user 102 under a "shared" management approach, where both the user and the managed database service 110 can manage these instances - for example, the user can directly access and / or customize the database engine 118, operating system 122, or associated applications, while the managed database service 110 can similarly manage overlapping aspects (e.g., patching, updating, etc. of the database engine and operating system) and / or aspects that are not accessible to different users (e.g., autoscaling, physical hosts and resources). In some embodiments, the database customization service 108, the managed database service 110, and / or other entities of the provider network 100 are implemented as software executed by one or more server computing devices in one (or typically multiple) geographic locations, such as within one or more zones or regions of a multi-tenant "cloud" provider network 100.

[0030] The provider network 100 provides users with the ability to use one or more of various types of computing-related resources, such as computing resources (e.g., executing virtual machine (VM) instances and / or containers, executing batch jobs, executing code without pre-configuring servers), data / storage resources (e.g., object storage, block-level storage, data archive storage, databases and database tables, etc.), network-related resources (e.g., configuring virtual networks (including multiple groups of computing resources), content delivery networks (CDNs), domain name services (DNS)), application resources (e.g., databases, application build / deployment services), access policies or roles, identity policies or roles, machine images, routers, and other data processing resources, etc. These and other computing resources may be provided as services, such as hardware virtualization services that can execute computing instances, storage services that can store data objects, etc. Users (or "customers") of the provider network 100 may use one or more user accounts associated with a customer account, but these items may be used somewhat interchangeably depending on the usage context. A user may interact with the provider network 100 via one or more interfaces (such as by using an application programming interface (API) call), via a console implemented as a website or application, etc. across one or more intermediate networks 106 (e.g., the Internet). An API refers to an interface and / or communication protocol between a client and a server such that if a client issues a request in a predefined format, the client should receive a response in a specific format or initiate a defined action. In a cloud provider network scenario, an API provides a gateway for clients to access cloud infrastructure by allowing clients to obtain data from the cloud provider network or cause actions within the cloud provider network, thereby enabling the development of applications that interact with resources and services hosted in the cloud provider network. The API may also enable different services of the cloud provider network to exchange data with each other. The interface may be part of or act as a front end to the control plane 130 of the provider network 100, which includes "backend" services that support and implement services that are provided more directly to customers.

[0031] For example, a cloud provider network (or just "the cloud") generally refers to a large pool of accessible virtualized computing resources (such as computing, storage and networking resources, applications, and services). A cloud can provide convenient, on-demand network access to a shared pool of configurable computing resources that can be programmatically provisioned and released in response to customer commands. These resources can be dynamically provisioned and reconfigured to adjust to variable loads. Thus, cloud computing can be considered to be both applications delivered as services over publicly accessible networks (e.g., the Internet, cellular communication networks) and the hardware and software in the cloud provider's data centers that provide these services.

[0032] A cloud provider network may be formed into multiple regions, where a region is a geographic area in which a cloud provider clusters data centers. Each region includes multiple (e.g., two or more) availability zones (AZs) connected to each other via a private high-speed network (e.g., a fiber optic communication connection). An AZ (also referred to as a "region") provides an isolated fault domain that includes one or more data center facilities that have separate power, separate networking, and separate cooling relative to a data center facility in another AZ. A data center refers to a physical building or enclosure that houses and provides power and cooling for the servers of a cloud provider network. Preferably, AZs within a region are located far enough apart from each other so that a natural disaster (or other event that causes a failure) does not affect more than one AZ at the same time or take more than one AZ offline.

[0033] To provide these and other computing services, the provider network 100 typically relies on virtualization technology. For example, virtualization technology can enable users to control or use computing resources (e.g., "computing instances," such as VMs using a guest operating system (O / S) that operates using a hypervisor that may or may not further operate on top of an underlying host O / S; containers that may or may not operate in a VM; computing instances that can execute on "bare metal" hardware without an underlying hypervisor), where a single electronic device can be used to implement one or more computing resources. Thus, users can directly use computing resources hosted by the provider network (e.g., provided by a hardware virtualization service) to perform various computing tasks. Additionally or alternatively, users can indirectly use computing resources by submitting code to be executed by the provider network (e.g., via an on-demand code execution service), which in turn uses one or more computing resources to execute the code - typically without the user having any control or knowledge of the underlying computing instances involved.

[0034] One service that may be provided in the provider network 100 is a database service, such as a managed database service 110. The database service 110 may be implemented as one or more software modules executed by one or more computing devices of the provider network 100. The managed database service 110 may be "managed" and thus enable users to easily set up, operate, and scale databases in the provider network 100 in the form of database instances 114 without the need to pre-configure computing instances, install database software, configure software, etc. The database service 110 may rely on the virtualization technology described above to allocate computing and storage resources to provide database instances 114. For example, the database service 120 may pre-configure the resources of one or more host devices (e.g., server computing devices) to host database instances. The database service 110 may provide resizable capacity when managing time-consuming database management tasks. The database service 110 may provide one or more of a variety of database engines 118 (e.g., relational database engines such as MySQL, MariaDB, Oracle (TM), SQL Server, PostgreSQL, etc., and / or non-relational database engines) that allow existing code, applications, and / or tools to work seamlessly. In some embodiments, the managed database service 110 may perform administrative tasks such as automatically backing up the database, upgrading and / or patching database software, scaling computing resources or storage capacity associated with its database instance, and the like.

[0035] A user 102 of the provider network 100 may interact with the database service 110 to launch and use one or more database instances 114. For example, the user 102 may utilize a console implemented via a web-based application to issue one or more requests to an endpoint associated with the database service 110 indicating that the user 102 desires to launch / configure one or more database instances 114. The database instance 114 may include a computing instance 128 (e.g., a virtual machine) having an operating system 122 and executing a database engine 118.

[0036] Each database engine has its own supported features, and each version of the database engine may include specific features. In addition, each database engine has a set of parameters in a database parameter group that control the behavior of the database it manages. Traditionally, database engines are implemented using a tightly coupled architecture, where the database engine determines how data is stored and is further associated with a proprietary data storage format. Such database engines typically maintain a catalog that describes how data is stored, such as as a collection of tables, columns, and data types. These database engines also include a query engine that is configured to query data using knowledge of the catalog and the proprietary data storage format.

[0037] Thus, a database instance can be viewed as an isolated database environment (e.g., running in the "cloud" means running in a service provider network) and can contain one or more user-created databases that can be accessed using the same client tools and applications that are typically used to access independent database instances. Each database instance can have a database instance identifier. In some embodiments, the database instance identifier is a user-provided name that uniquely identifies a database instance (e.g., unique to that user in a region) when interacting with the database service 110 (e.g., via an API and / or CLI command). The database instance identifier can be used as part of the DNS host name assigned to the instance by the database service. For example, if a user specifies "db1" as the database instance identifier, the database service 110 can automatically assign a DNS endpoint 126 to the instance, such as "db1.123456789012.usa-east-1.dbservice.example.com", where "123456789012" is a fixed identifier for a specific region of the user's account. When creating a database instance, some database engines require that a database name be specified. A database instance can host multiple databases, or a single database from some vendors can have multiple schemas. Therefore, the Database Name value can depend on the database engine.

[0038] In some embodiments, the managed database service 110 may support multiple different types (or types of classes) of database instances, where the type of a database instance generally refers to a specific combination of the number and type of computing resources (e.g., processing power, such as the number of cores, memory, available bandwidth, etc.) of the associated computing instance 128. Multiple types of instance classes may be supported (e.g., standard, memory optimized, burstable execution, etc.), where each class may have multiple different types or sizes thereof. For example, a "standard" instance class may have multiple different instance types, such as "8XL" or "16XL", and each instance type of the same class may or may not support the same database engine or version thereof (e.g., all versions of MariaDB, only versions of PostgreSQL less than version 13, etc.).

[0039] The computing instance 128 may also run one or more agents 124, e.g., to collect performance-related data (e.g., metrics) associated with the database engine 118, the operating system 122, and / or the computing instance 128 itself. In some embodiments, the database instance 114 is further associated with an endpoint 126 (e.g., associated with a network address) that can be used to access the database engine 118.

[0040] In response to the request sent on behalf of the user, the management engine or controller (not shown, but belonging to the control plane 130) of the database service 110 can then perform operations to obtain computing resources (e.g., a VM executed by a host device) for the database instance 114 within the provider network 100, start the VM image (optionally pre-installed with code for the database), optionally start or install the database on the host device, configure the database instance 114, configure security rules and / or permissions used by or for accessing the database instance 114, etc. Thereafter, a database client application (e.g., an external client 105A and / or a client 105B within the provider network) can issue queries / statements (as database traffic 136) to the database instance 114 to read data from / write data to the database. Such a database client application can be executed by an electronic device within the provider network 100 (e.g., hosted on a virtual machine) or outside the provider network 100, and interact with the database instance 114 via the network 106 and / or the endpoint 126. In some embodiments, transactions may be sent using Hypertext Transfer Protocol (HTTP) messages to an endpoint associated with a database instance 114 that provides an HTTP-based interface.

[0041] In embodiments disclosed herein, the managed database service 110 may include a database customization service 108 that allows a user to define and create a custom database engine version (CDEV) for a particular database that the user wishes to utilize, where the databases may be considered "custom" in that they may not be natively supported by the existing fully managed database offering of the managed database service 110. Thereafter, the CDEV may be used by the user 102 or associated users (e.g., users of the same organizational account, or even users from entirely different users or accounts, such as by sharing the CDEV via a CDEV marketplace) to launch a custom database instance 114 that may be jointly managed (e.g., by allowing the user to directly access the host while the managed database service 110 may also perform traditional management tasks). The CDEV may be in a variety of formats—for example, a CDEV may include a "snapshot" (e.g., a binary volume snapshot) taken of a database version and a machine image.

[0042] A machine image can be a master image that creates a virtual server (compute instance) in a provider network environment. A machine image can include (or reference) one or more volume snapshots or templates of instance root volumes (e.g., operating system, application server, and application). A machine image can also include: launch permissions that control which provider network accounts can use the machine image to launch instances, and / or block device mappings that specify volumes that are attached to the instance when the instance is launched.

[0043] In some embodiments, user 102 may begin the process of creating a CDEV by uploading database software in the form of database installation files 142 to storage location 140 (e.g., a virtual folder / directory / bucket provided by a storage service 132 such as an object storage service) as shown at circle (1). For example, a user may interact directly with storage service 132 to upload files / data as described herein; however, in other embodiments, a user may upload such material to storage service 132 indirectly via use of a console or other application provided by database customization service 108, which may itself store the material to one or more storage locations 140.

[0044] The upload may be performed in a storage location 140 associated with the same area of ​​the provider network that will be used to create the CDEV. The database installation files 142 may be in an uncompressed form (e.g., uploaded file by file) or in a compressed or merged format (e.g., within a ZIP file, TAR file, etc.). The storage location 140 may be within, for example, a folder or bucket owned / controlled by the user.

[0045] For example, Figure 2 is a diagram illustrating an exemplary database installation file, a custom engine version manifest, and a set of database patches for building custom database software in a shared management environment of a cloud provider network, according to some embodiments. Figure 2 , an example set of uploaded database installation files 142 is provided as "V982063-01.ZIP", which may include database binaries or executable files, a set of source files that can be used to build an executable database engine, etc. The database installation files 142 are also shown as having a set of patches 144 to be applied to the database engine, for example, the patches are executed and / or built based on the use of V982063-01.ZIP. As used herein, the term "patch" can be used broadly to cover various types of updates or changes to software modules, and may include code to fix problems with other software (e.g., vulnerability fixes), add additional code to software (e.g., install new drivers), address new security defects, address stability issues, upgrade existing software, etc.

[0046] Transfer back Figure 1, at circle (1), the user may additionally (or alternatively) upload a user-defined manifest 146 for CDEV. The manifest 146 may be a document (e.g., a formatted document, such as a JSON file) that describes the installation files for CDEV, including, for example, the file name, the file location (e.g., a URL), etc. The manifest 146 may also identify other configuration operations to be performed as part of the build (e.g., operating system and / or database engine configuration), identify other software to be installed (e.g., database extensions, third-party software) or other software to be run (e.g., user-provided scripts), etc. The user may save the CDEV manifest as a file or edit the template when creating a CDEV using a console application provided by the database customization service 108. Refer again to Figure 2 , the example CDEV manifest 146 lists the files uploaded to the storage location, and the database customization service 108 builds the CDEV based on this information to apply the patches in the order in which they are listed. In this following example, the database customization service 108 will first create a database using the database installation file V982063-01.ZIP, and then apply the patches in order, for example, first "p32126828" (as indicated by "p6880880_190000_Linux-x86-64.zip" appearing as the next listed file), followed by "p32126828", then "p29782284", and so on.

[0047] This example manifest is oriented toward creating a custom Oracle-type database engine, and therefore includes fields and values ​​specific to that engine; however, in other embodiments, other types of databases, fields, etc. are used, which may be generic or specific to a particular database engine. In this example manifest, the "MediaImportTemplateVersion" field provides a user-specified version of the CDEV manifest, where the date format is YYYY-MM-DD. The "databaseInstallationFileNames" field provides an ordered list of installation files, and the "opatchFileNames" field (e.g., which can be used to construct an Oracle database) provides an ordered list of OPatch installers for the Oracle DB engine. The "psuRuPatchFileNames" field provides a similar ordered list of patch set update (PSU) patches (e.g., including security and / or regression fixes) and / or release update (RU) patches, while the "OtherPatchFileNames" field provides other patches, such as patches that are not in the list of PSU and RU patches, and these "other" patches can be applied after the patches defined earlier.

[0048] like Figure 1 As shown, optionally, the user may provide other related files (such as a machine image 148 to be used to create the computing instance), and / or other code 150, which may be run before, during, or after the build process to further customize the resulting database instance according to the user's wishes (e.g., install additional extensions, management software, related applications, etc.).

[0049] Thereafter, as reflected by circle (2), user 102 may use his electronic device 104 to interact with database customization service 108 to create a CDEV. Such interaction may be performed via an interface (such as a graphical user interface (GUI)) provided by database customization service 108, for example, as part of a web-based console application. Figure 3 300 that can be used to customize database engine creation according to some embodiments. In GUI 300, a user can utilize various user input elements (e.g., text input boxes or text areas, drop-down boxes, icons, check boxes, radio buttons, etc.) that the user can utilize to provide input to control the CDEV creation process. In this example, input element 305 allows the user to select between specific database engines that the user is committed to building (or in some embodiments, the user can enter a new value for a new version of the engine). Using input element 310, the user can select or provide an identifier for a specific major version of the engine.

[0050] In this example interface, the user may also provide a user-specified name for the CDEV via input element 315 and / or a description of the CDEV via input element 320. These names and descriptions may be used by the user (or other users of the same organization, or even other unrelated users) to uniquely identify the CDEV (in some contexts, such as an organization's CDEV) and understand what the CDEV is—e.g., what it includes, what it is used for, etc.

[0051] The user may also provide an identifier of a storage location where the installation files are located, and / or an identifier of a storage location where the manifest is located, via input element 325. However, in some embodiments, the user may be able to create the manifest directly from this GUI 300 or via a linked GUI, such as by presenting a text area into which the user may type the manifest. Additionally or alternatively, in some embodiments, a draft of the manifest may be created by database customization service 108, such as by scanning a location identified by the installation file location and pre-populating a list of files, or otherwise providing these files to the user so that the user may arrange the files as desired (e.g., place the files in the correct order according to the installation order).

[0052] In some embodiments, the user may also configure the underlying host, for example, by selecting a particular instance type (e.g., a particular resource configuration having a certain amount of computing power, memory capacity, bandwidth capacity, additional accelerators or capabilities, etc.) via input element 335, identifying an operating system via input element 340 (e.g., by selecting from a list of known available operating systems, or by providing a link to a user-provided operating system, such as a machine image 148 stored by the user in storage location 140), and / or providing operating system configuration values ​​via input element 345 (e.g., setting a computer name, updating passwords, default values, etc.).

[0053] This configuration can allow the user to indicate how to build, verify CDEV, or how to configure the database instance created later. For example, as shown in the figure, GUI 300 can allow the user to indicate in which relevant stage to use this configuration-here, via check box 347 indication, the user can indicate that the computing instance related configuration will be used to build CDEV and also verify CDEV. For example, the user may wish to control the resources used for building and verifying, such as when using the license restrictions based on multiple cores, vCPUs, etc. associated with the database engine. Therefore, GUI 300 can allow the user to indicate the maximum number of cores (e.g., ten) that can be used in all CDEV constructions and / or verifications carried out simultaneously. As another example, the user may wish to use a "smaller" computing instance (e.g., with relatively few or low-performance processing resources, memory, etc.) to perform construction and use a "larger" computing instance to perform verification, and therefore the user can configure the number and / or type of the instance to be used individually for a separate stage.

[0054] After completing this process, the user may select a "create" input element 350 to send this information (or just a command, such as when the interface has already sent the user-provided data to the database customization service 108) to cause it to begin generating the CDEV. Such a submission may result in an API call being issued, such as a "create-custom-db-engine-version" call to an endpoint of the provider network, which includes the user-provided data from this GUI 300. Of course, in other embodiments, such a GUI 300 may not be required, and the user may provide such information in other ways, such as in a separate configuration file, directly as a parameter in an API call, etc.

[0055] In some embodiments, this process may include using a database installation file 142 stored external to the storage location 140 of the provider network 100. For example, a user may provide (e.g., via a manifest 146, or via a parameter to a call made at circle (2)) an identifier of a publicly available source code repository (e.g., provided by a repository service / website, hosted by a private server, etc.), an identifier of a set of one or more files hosted or provided by a website (e.g., a website of an open source project that makes binaries and / or source code available for download) or a distributed peer-to-peer type system, etc.

[0056] Transfer back Figure 1 , at circle (3), the database customization service 108 may perform a multi-stage build process for the CDEV, resulting in the creation of a CDEV (e.g., a binary volume snapshot / backup of the database volume and machine image), which may be used to start the corresponding database instance. The CDEV may be stored back to a storage location accessible to the user, or to a location accessible only to the database customization service 108 and / or the managed database service 110. The CDEV build process as described herein may involve various stages, such as pre-check verification, build, post-check verification, etc. The details of these stages will be presented in detail later herein.

[0057] Once the CDEV is created, the user (or another associated or unassociated user) may interact with the database customization service 108 to utilize the CDEV to launch one or more database instances 114, as shown at circle (4). In some embodiments, the one or more database instances may be launched by the managed database service 110 using resources controlled by the managed database service 110, but in other embodiments, launching may include launching database instances using compute instances provided by a provider network's hardware virtualization service (e.g., under a user account, giving the user direct ownership of the instances), or even launching in a completely separate environment (such as a third-party cloud provider network, a user's on-premises location or data center, etc.). In these scenarios, the managed database service 110 may perform the launch for the user itself, or may provide the user with a customized database engine version 112 so that the user can launch the instance on his own.

[0058] However, under a shared management model where the managed database service 110 partially manages the lifecycle of the database instance 114, at circle (5A), a user (via client 105A) can directly access the compute instance 128 to perform management-type operations 138, while the database customization service 108 (or a component of the managed database service 110) can also be able to perform management operations 134, as shown at circle (5B). In addition, one or more clients 105A-105B can utilize the database instance 114 in a typical manner, and thus database traffic 136 can be sent between them, as shown at circle (6).

[0059] For further details, Figure 4 is a diagram illustrating an environment for utilizing a custom engine version of database software in a shared management environment according to some embodiments. A user 102 may use CDEV by utilizing an electronic device 104 via a client 105A (e.g., an application such as a web browser, a dedicated application, etc.) to send one or more requests to a database customization service 108 as shown at circle (0) to launch a database instance 114 based on the CDEV. The request may include an API call of the "create database instance" type, which is similar to other calls used by traditional managed database services, but here, it specifically includes an identifier of the CDEV to allow the managed database service 110 to launch the specific custom database software. Additionally or alternatively, a user may instead use CDEV to create a database instance by using a graphical interface (such as a web-based console) to select the CDEV of interest, optionally provide other database configuration data, and instruct the database customization service 108 to launch the database instance.

[0060] After starting the database instance 114, the control plane 130 (of the managed database service 110) may perform management operations as reflected in circle (1), which may include monitoring the performance of the computing instance 128 and / or the database engine 118 (e.g., throughput, task completion rate, or bandwidth, etc.), monitoring the resource utilization of the computing instance 128 (e.g., CPU utilization, bandwidth utilization, memory utilization, etc.), etc., and further configuring the database instance 114 as needed (e.g., via messaging with a hypervisor or manager-type component supporting the computing instance 128, via messaging with one or more agents 124) to ensure the performance of the database instance 114.

[0061] In some embodiments, user 102 may perform management of database instance 114 by sending a command to database customization service 108 at circle (2) indicating a desire to perform such management. This may ensure system stability, for example by suspending possible management automation performed by database customization service 108 to ensure that the user's management operations do not interfere with the management operations of database customization service 108. Thus, user 102 may cause client 105A to send a command (e.g., via an API call, via use of a web-based application, etc.) to suspend (or suspend) management of the database customization service for a period of time, where the period may be a defined amount of time or an undefined amount of time, such as a user-provided time or a default time, such as 60 minutes, 90 minutes, 24 hours, etc. Thereafter, at circle (4), the user may perform management actions, such as by directly connecting to compute instance 128 (e.g., via an SSH connection) or indirectly managing the instance via a separate system manager service 402, which may itself perform management operations on behalf of the user.

[0062] When the "pause" period expires, and / or when client 105A sends a command to end the pause period (as reflected by optional circle (5)), database customization service 108 can resume its management operations (e.g., monitoring, instance recovery) at circle (6). Thus, as needed, users can perform management of database instances that they were previously unable to perform in the managed database environment, while database customization service 108 (or other modules of managed database service 110) can continue to manage these database instances on behalf of the users.

[0063] In some embodiments, at the end of this "pause" period, the database customization service 108 may access a record of changes made by the user 102 to the database instance 114. For example, the agent 124 may monitor management traffic and record (and / or transmit) a log or summary of changes that occurred, commands issued, etc. Additionally or alternatively, the system manager service 402 may provide this summary to the database customization service 108, and / or another monitoring service (obtaining logs from computing instances on the provider network) may likewise be able to provide information about the activity of the database instance 114 to the database customization service 108. The database customization service 108 may use this information to determine the update state of the database instance 114, for example to avoid problems caused by later management operations that expect it to be in a different state, to detect (and report or repair) potentially problematic actions performed by the user during this time (e.g., erroneous actions that caused problems, policy violations, etc.), etc.

[0064] As noted above, the database customization service 108 creates a custom engine version for a user that can be used to run a custom database instance that can operate under a shared management model. In some embodiments, this creation process includes a build operation and a validation operation. For example, Figure 5 1 is a diagram illustrating aspects of a database customization service for building and validating custom database software according to some embodiments. As shown, the database customization service 108 includes: a build engine 502 for building a CDEV 512 via use of a computing instance 128A; an engine version metadata 506 data store for maintaining data describing the CDEV and / or the build process; and a validation engine 504 for validating the build (e.g., in pre-build validation 505A and / or post-build validation 505B) to ensure that it functions properly and that the database instance launched using the CDEV conforms to the requested properties.

[0065] As described herein, database software in the form of CDEV of a database engine can be built by a build engine 502 according to a "media" file provided (or selected / identified) by a user in the form of a database installation file, which may include source code, target files, shared libraries, executable files, etc. This database software usually runs on a specific operating system (OS) configuration. Metadata describing the database software, operating system, and its configuration can be stored in the engine version metadata 506, such as DB / OS vendors, version information, installed components or features, patches or bug fixes, additional software, and / or dates associated with any or all of the above. In some embodiments, the database customization service 108 can therefore support a "bring your own media" (BYOM) feature, in which the user provides database media and optionally provides or specifies its DB / OS configuration and additional software 550A-550B. For example, the user 102 can provide an OS configuration based on a specific OS vendor or OS distribution, as well as the version of the OS, and optionally enable additional features (e.g., database extensions), install software (e.g., antivirus software), or install patches. The database customization service 108 can then provide automation and security guardrails for the construction of the CDEV. The resulting CDEV that is built and verified can run in a managed database service 110, or the database customization service 108 can be a standalone service where users can download and run the resulting engine version in a self-managed environment.

[0066] In other systems where users will manually build their own engine versions, these users will need to look up community and / or vendor documentation on how to build engine versions and determine what the best practices are. Users will also need to stay abreast of potential issues that have been discovered with database media files, build processes, or DB / OS configurations. In addition, users will need to manually test new engine versions or write their own automation to do this.

[0067] In contrast, the embodiments disclosed herein can eliminate this burden and complexity by automating the build process via a build engine 502 in response to a user request at circle (1), and validating the resulting CDEV that the user wants to create via a validation engine 504. This validation may occur in the context of an OS configuration provided by the database customization service 108 and / or the user. Optionally, the user may specify a specific DB / OS configuration and / or additional software 550 for validation. Additional software 550 may include database extensions, external programs, plug-ins, independent third-party software, operating system libraries or features, etc. Through the validation engine 504 at circle (2), the database customization service 108 can validate that the provided media, DB configuration, and OS configuration will produce a "valid" or expected engine version. To help achieve this, the database customization service 108 can track metadata related to the DB media, DB / OS configuration, and additional software in the engine version metadata 506. This metadata can be used by the validation engine 504 as a pre-check before actually building the engine version.

[0068] After the initial pre-check, the build engine 502 can then run a build operation 530 at circle (3) to build / compile / install media on a database instance 114A with the requested DB and OS configuration and optional additional software 550A. After this, the verification engine 504 can perform some post-build verification 505B checks for the new engine version at circle (4). Build verification can include checking logs, exit codes, or performing other logical checks to determine whether the build step is successful. Build verification can also include running commands to ensure that the build of the database software appears to be valid and / or has the required patches, bug fixes, enabled / disabled features, or other additional software 550B installed correctly. This pre-check verification of the metadata for the engine version metadata 506 enables the database customization service 108 to quickly notify users that there is a problem with the specification of the engine version they want to build. This will save users a lot of time and the cost of running the build process and / or performing post-build verification. Such metadata of the engine version metadata 506 stored and utilized may include information about the database media, OS, or additional software that allows the database customization service 108 to determine whether it is from the correct source and remains unchanged, for example, using methods such as generating and comparing file checksums (compared with the file checksums published by the media author), repository tags, change numbers, or other methods. The engine version metadata may also include or alternatively include information such as the date on which the media, OS, or other additional software became available, the number of vulnerabilities, and / or dates related to security / vulnerability fixes, or whether there are any problems with the media, OS, or other additional software. Vulnerability fixes may include identifiers from databases, OS, or other software. Metadata may include public vulnerabilities or security issues, such as Common Vulnerabilities and Exposures (CVE) numbers or provider network internal vulnerability tracking information. Metadata may also include dependencies or conflicts with media, OS configurations, or other additional software - from public sources or from observations or testing of the database customization service 108.

[0069] An operator of the database customization service 108 may also perform tests or studies that may then feed back into such metadata 506. For example, in some embodiments, an operator (or an automated process within the database customization service 108, such as via an earlier run of a build process) may mark a media file or DB / OS configuration as causing database corruption, having functional issues, or having stability or performance issues. Such metadata 506 may then be used when building additional engine versions to determine whether the build will produce a valid and secure engine version. For example, if the database media includes a known vulnerability that causes database corruption, if the OS is incompatible with or not certified for the DB engine version, if there are conflicts or missing dependencies, etc., the database customization service 108 may exit the build with an error, or provide a warning to the user.

[0070] In some embodiments, the user may specify optional database functions to be enabled / disabled or additional software that should be installed. The user may also provide an indication of the application with which the engine version will be used. Therefore, in some embodiments, additional pre-check verifications may be performed based on these factors, or additional dependencies may be added. For example, the expected application may be a specific business suite application, and metadata 506 may include information about required patches, or database functions, or DB / OS configurations, or additional software required for the application or version of the application. The user may specify this expected application as part of the build process, or the expected application may be inferred based on the provided media files, the included optional database functions, and / or DB / OS configurations.

[0071] Assuming all pre-check verifications 505A are successful, in some embodiments, the build engine 502 may then perform a build 530 at circle (3). This may include obtaining a compute instance 128A (e.g., launching or obtaining an already existing instance) and creating and / or installing and / or configuring a database engine 118A using provided installation files in accordance with user-submitted requirements. Metadata for such a build may be stored in a metadata 506 data store, and a CDEV 512 may be generated based on the use of this compute instance 128A. As an example, a volume snapshot (e.g., a point-in-time copy of a volume used by a compute instance 128A) including database engine code and / or data may be taken to generate a volume snapshot 514, which is part of or referenced by a CDEV 512, such as via a URL or other resource identifier when an image 516 is stored external to the CDEV 512. In some embodiments, an image 516 of the compute instance 128A itself (obtained from the actual compute instance 128A, or if there is no O / S customization, from a generic instance) is also included in the CDEV 512, or a reference to the image 516 is included in the CDEV 512. Additionally, in some embodiments, the CDEV 512 also includes or references setup code 518, which can be executed to customize a newly launched instance (e.g., based on the image 516) and / or a newly launched database engine 118A (e.g., based on the volume snapshot 514) according to the user's preferences.

[0072] After the engine version 512 is built, the verification engine will optionally verify at circle (4) whether the resulting engine version has the expected functionality, is stable, and / or performs well. The verification engine 504 can run one or more verifications on the engine version of the running database instance 114B started based on the CDEV 512 via the test traffic 540 at circle (4).

[0073] Post-build validation 505B may include verifying that the engine version and OS configuration will allow the database to be successfully created. It may also include validation of the database instance 114B created by the engine version, including checks such as checking for incomplete or invalid components or features in the database, running functional tests to ensure that the database works correctly, running performance or stability tests, and / or testing a database "upgrade" between a previously created engine version and this new engine version.

[0074] The type of validation performed for new engine versions may be based on the configuration that the managed database service 110 has for the database engines, or may be based on user input, or some combination of the two. For example, a customer may want or not want to test a particular database feature based on whether they are using that feature, have it installed, and / or have a license for that feature. Additionally, choosing not to run all post-build validation tests may reduce the time spent building and testing an engine version, or may reduce the cost of resources used for verification.

[0075] As described herein, if the metadata associated with the media files and / or DB / OS configuration does not meet the user's requirements, the database customization service 108 can provide protection measures with errors or warnings during the build process of the new engine version (e.g., sent to the user's device attempting to create the CDEV). These user requirements can be obtained from the user by the database customization service 108 in the form of policies created via the GUI. For example, Figure 6 is a diagram illustrating an exemplary graphical user interface 600 for obtaining a user-configured build and run strategy for CDEV management according to some embodiments. This GUI 600 can be provided via the database customization service 108, such as by sending data for this interface (e.g., a web page or associated code) to a user's computing device.

[0076] For example, a user (such as an administrator of an organization) may want to ensure that CDEVs with specific characteristics can (or cannot) be built throughout the organization (e.g., by other user accounts within the same organization). Therefore, this user can configure a set of build policies to implement these desired goals. For example, GUI 600 presents various user input elements (e.g., check boxes, text input areas, radio buttons, etc.) to allow users to create custom policies to manage the construction of CDEVs that can be implemented using evaluable logical conditions. For example, a user may wish to require that only CDEVs of open source DB engines or commercial DB engines be built, only specific major versions of DBs be built, a specific "flavor" of OS be used, specific vulnerability fixes be included, the build does not contain any "critical" CVE flaws (or CVE flaws of a specific level or severity, severity scores are above a threshold, etc.), the build includes the latest or most stable set of installation files, security fixes do not exceed a certain amount of time, the build will meet the requirements of a given standard / compliance program (e.g., HIPAA, FedRAMP, PCI), etc.

[0077] Similarly, the database customization service 108 may also provide a user interface to control the use of CDEVs in launching and running database instances. For example, a user may desire not to run database instances with critical CVEs. Thereafter, although a group of multiple database instances that meet this criteria is initially launched, a CVE that is subsequently discovered to affect the group may allow the database customization service 108 to detect this problem and respond according to the user's expectations - for example, notifying the user, terminating the database instances, increasing the security value applied to the traffic using these instances, automatically patching the database instances, placing the instances in network isolation (for example, limiting or removing network connections to and / or from the instances), etc.

[0078] To implement these policies, in some embodiments, the database customization service 108 includes a compliance engine that implements such controls, for example, via the use of user-defined policies. These policies can be used during the build process (e.g., before build, after build) and / or during the use of these CDEVs or the resulting database instances. Figure 7 is a diagram illustrating one such compliance engine 700 of a database customization service according to some embodiments, the compliance engine including a data store that stores policy and / or control data 702 corresponding to user-configured policies. Such policy and / or control data 702 may be used by the build engine 502 and / or the validation engine 504 (as shown), and / or by the database customization service 108 (or related services) to monitor the ongoing use of a database instance launched from a particular CDEV.

[0079] Users may want to control what validations are performed for a given engine version and how they are performed. For example, users may want to ensure that a certain database function is tested (or specifically not tested), ensure that specific optional database functions are included or not included, or they may want to limit the amount of resources used for testing simultaneously or over time. If performance or stability testing is specified, the policy can indicate thresholds based on performance or stability metrics, either as an absolute metric or as a comparison to a previous engine version.

[0080] Thus, the database customization service 108 may provide organizations with the ability to create "policies" that define rules for building and validating engine versions. The building of engine versions may be done by specific people or organizations within the company that are separate from the people or organizations responsible for policies. A company may want to ensure that the building process for a new engine version meets its compliance requirements, internal security rules, legal / contractual requirements, and / or organizational preferences. Users may not need to set policies when creating a CDEV, but may also specify their requirements whenever they build a CDEV.

[0081] For CDEVs built by managed database service 110, users may also want to evaluate whether these new engine versions meet the policies they have set for their organization or user accounts. In this case, managed database service 110 builds the engine version based on its selected "recipe" and optionally makes the engine version available to users. If a given managed database service 110 engine version violates its policies, the user may not want to make it available for use within its company.

[0082] Policies may also apply to running database instances, not just newly built engine versions. The managed database service 110 may notify the user and / or take action when an existing database instance no longer meets its policy rules. This may be due to the "aging" of the engine version based on compliance or security requirements around how old security patches the engine version may contain. It may also occur due to changes in the score or severity of a given vulnerability or CVE flaw, or changes in the internal managed database service 110 determination of the criticality of a given vulnerability, or it may change based on modifications made by the user to the policy or the running instance itself. For example, a user may manually manage a database instance and turn on or otherwise enable specific features that are prohibited according to policy, such as the use of partitions in the database engine, the use of specific features of the operating system (e.g., security controls), etc.

[0083] In some embodiments, the managed database service 110, via the monitoring engine 704, may upgrade or schedule an upgrade of a running database instance (e.g., a production instance 706) from a "source" engine version or DB / OS configuration that no longer satisfies a user's policy to a "target" engine version or OS / DB configuration that does satisfy the user's policy. For example, when a new CVE is published, the compliance engine 700 may identify a running production instance 706 that no longer has a policy that is satisfied (e.g., via the policy and / or control data 702), such as by identifying an implemented policy that causes an existing database instance 114C-114N to operate in violation of the CVE due to the presence of the CVE. Alternatively or additionally, the monitoring engine 704 may perform these operations, for example, by monitoring the state of production instances 706 (such as database instances 114C-114N) to identify these scenarios, either directly (via interaction with the instances 706) or indirectly (e.g., via analysis of metadata 506 indicating the current state of the database instances, and / or policy and control data 702 indicating specific policies that have been implemented, and / or data obtained from a separate monitoring or log providing service of the provider network, and / or via a set of knowledge bases 706 providing information about security issues, etc.). When it is determined that such new non-compliance scenarios exist, the database customization service 108 may act in a variety of ways that are configured based on the expectations of the affected users and / or the expectations of the provider. For example, the affected database instances 114C-114N may be upgraded to one or more new versions that will satisfy their corresponding policies (e.g., applying a new patch that addresses the CVE), affected users may be notified, enhanced security measures may be enabled for traffic (e.g., additional authentication, additional malicious activity inspection), the instances may be placed in network-type isolation in which some or all traffic is not allowed to be sent to and / or from the instances (until the user stops the isolation and / or eliminates the policy noncompliance), etc.

[0084] In the scenario where upgrades are performed, these upgrades may be restricted based on the declared preferences of the associated user. For example, upgrades may be restricted to engine versions within the same major engine version of the source engine version and / or may be restricted to engine versions that contain a superset of media files, features, or bug fixes. Alternatively, users can configure their policies so that only users are notified of problems instead of automatically scheduling upgrades. Similarly, if no compatible upgrade is found, the managed database service 110 may decide to only notify the user, or the managed database service 110 or the user may instead choose to disable or "network isolate" their database instance immediately or after a certain grace period has passed if a policy violation is found. Upgrades can also be run automatically when creating a new instance, or when restoring a database, or when a user specifies that a new instance or restore cannot be implemented on an engine version that does not meet their policies.

[0085] In some embodiments, the database customization service 108 may also include a recommendation engine 720 that provides recommendations to users about the CDEVs they are trying to build. This recommendation engine 720 may also utilize the metadata 506 and / or the knowledge base 706.

[0086] When the managed database service 110 builds an engine version, it utilizes a set of best practices that result in a stable, secure, and well-performing engine version. These best practices sometimes come from the community or database vendor, but may also come from testing within the provider network or lessons learned over time. These best practices may be provided to users of the database customization service 108 as a set of recommendations. For example, there may be different types or "flavors" of recommendations, such as a "latest stable" configuration, a "latest" configuration, a "latest secure" configuration, etc., each of which corresponds to a set of recommended values / configurations for a CDEV build (e.g., installed software versions, recommended patch sets, tuning options, etc.).

[0087] In some embodiments, the database customization service 108 may provide recommendations based on the applications that the user is committed to running, the compliance standards / programs that their applications need to meet (e.g., HIPAA, FedRAMP, PCI), etc. These recommendations may include suggestions about engine version software (e.g., using a specific engine vendor project / product, using a specific version, etc.), or other database configuration related aspects (such as database parameters or optional components / features to enable / disable or add). Recommendations may also include OS configurations. The database customization service 108 may make such recommendations the default behavior when building engine versions, or the user may optionally enable or disable recommendations. Engine versions that enable recommendations but do not complete these recommendations may throw warnings / notifications to the user, or the database customization service 108 may also fail to complete the build / abort the build. Optionally, in some embodiments, the recommendation engine 720 may be used to run recommendation checks on existing previously created engine versions upon user request.

[0088] Recommendations may include ensuring that the latest media or DB / OS configuration is used in the build. For example, a user may not be aware that a new major or minor version is available for the engine, or that there are updated patch sets, cumulative updates, or individual patches. Database updates may include recently released security fixes, time zone rule updates, updates to vendor recommended patches, updates to recommended DB configurations, updates to recommended OS configurations, or updates to what is considered the most stable release. Recommended changes may be input by an operator of the managed database service 110 and / or may be automatically updated (e.g., via data obtained from a third-party source, such as a CVE information provider, a database vendor, etc.).

[0089] Figure 8is a diagram showing exemplary information types utilized by a compliance engine and / or recommendation engine of a database customization service according to some embodiments. As noted above, the compliance engine 700 may utilize a variety of different types of information to detect scenarios where a database instance (or CDEV) does not comply with an associated user configuration policy. In some embodiments, the compliance engine 700 includes (or owns / manages) a policy and / or control data 702 data store, which includes policy-related information, such as a set of CDEV build policies 802 that are configured by the user to control the build process of a single build or any build associated with a user or the user's organization or unit (e.g., requiring a specific configuration or not allowing a specific configuration). The policy and / or control data 702 data store may also include, for example, an instance execution policy 804 that defines user-configured controls for subsequent execution of a database instance, and may specify whether, when, and / or how to perform an upgrade via an upgrade policy 806. One such upgrade policy 806 may indicate that the instance is not to be upgraded automatically, but rather that one or more associated users are to be notified; another such upgrade policy 806 may indicate that if a policy-compliant version of the instance can be produced via the upgrade, the upgrade should be performed at a certain point in time - for example, as soon as possible, at a specific time of day, or on a certain day of the week, etc.

[0090] The compliance engine 700 can analyze information from various sources to determine whether a policy has been violated. For example, the compliance engine 700 can monitor a set of knowledge bases 706 to identify the presence of new security vulnerability issues (e.g., via a vulnerability knowledge base 824 that is manually and / or programmatically updated), and / or check a database engine knowledge base 820 and / or an operating system knowledge base 822 to determine the characteristics of a particular database engine or operating system, such as to determine whether a particular engine or O / S is affected by a particular vulnerability, etc.

[0091] The compliance engine 700 may also analyze metadata 506 as disclosed herein, which may include information that allows the compliance engine 700 to identify and analyze CDEVs (via CDEV metadata 810) and / or database instances that are running and started via the use of CDEVs (via CDEV usage metadata 812) that may no longer comply with associated policies. The CDEV metadata 810 may indicate specific features or configurations associated with the CDEV - for example, it may track a patch list associated with the CDEV - which may enable the compliance engine 700 to determine whether it is vulnerable to a particular security defect. The CDEV usage metadata 812 may include information that allows the compliance engine 700 to identify running instances corresponding to a particular CDEV (e.g., via a mapping of instance identifiers to CDEV identifiers). This may allow the compliance engine 700, for example, to identify running instances corresponding to CDEVs that no longer meet policies, thereby allowing further study of these instances, possible upgrades, etc.

[0092] The recommendation engine 720 may also utilize the metadata 506 and the knowledge base 706 to generate recommendations. For example, the recommendation engine 720 may make recommendations to the user based on comparing the CDEV configuration provided by the user with the CDEV configurations of other users (via lookups in the CDEV metadata 810), thereby creating similar CDEVs to identify differences that can be highlighted to the user - for example, if there are a large number of other CDEVs with very similar configurations, and they include a patch that the current user has not specified, then this patch can be identified to the user as a suggested patch.

[0093] The knowledge base 706 may also store metadata about related patches or similarities between patches in the patch knowledge base 826 and provide it as a recommendation to the user. For example, if a user chooses to install a patch that fixes a corruption problem of a large object data type (LOB), the recommendation engine 720 may recommend different patches that are known to improve the performance of the LOB. In some embodiments, the knowledge base 706 may also store metadata about related software or features in the additional software knowledge base 828 and generate recommendations to the user based on this information. For example, the additional software knowledge base 828 may store identifiers of software packages that may be useful to various types of users, for example, users who will use a specific type of application (or use a database in a specific way) may benefit from (or need) the additional software installed, such as incorporating a geographic information system (GIS) extension into the database engine that can be used to perform geography-related operations that are known to be utilized by a specific application. Thus, required or beneficial additional software packages may be identified and recommended to the user.

[0094] Fig. 97 is a diagram illustrating an exemplary graphical user interface including recommendations during custom database engine creation according to some embodiments. As noted herein, the recommendation engine 720 may provide recommendations during the CDEV definition process in which a user provides information to create a CDEV, but in some embodiments, recommendations may also be made at other points, such as after a user submits a CDEV build request, after a CDEV is created (possibly at a later time), etc.

[0095] In this example GUI 900, based on the user selecting an outdated minor version, a first recommendation is made in user interface element 905. In this case, recommendation engine 720 may obtain such a CDEV definition from the user's input (e.g., an identifier of the selected edition and / or major version), determine that a new minor version exists (e.g., via a lookup in knowledge base 706 and / or metadata 506), and cause the interface to be updated to present this recommendation to the user via element 905.

[0096] In this example GUI 900, a second recommendation is made in user interface element 910 based on a patch provided by the user as part of database installation files 142. In this example, the user may have provided the location of database installation files 142, and database customization service 108 may analyze these files and, referring to patch knowledge base 826, determine that a patch related to a particular feature (here, LOB objects) is included, and one or more other patches also related to that feature (here, improved LOB object handling) may or should be included as well.

[0097] Additionally, based on the determined (or inferred / predicted) type of application that the user plans to use with the database instance generated by CDEV, a third recommendation is provided in user interface element 910. In some embodiments, the user may explicitly indicate which application to use (e.g., via a user interface element), but in some embodiments, the database customization service 108 may identify a CDEV fingerprint that matches a known application (e.g., a specific set of options, such as a specific database version, major version, set of installation files, etc.), and may recommend any missing or incorrect aspects of CDEV that are required or helpful for use with the application. In this example, user interface element 910 indicates that additional patches may be helpful and that a specific database configuration may be warranted, where the user may click on this recommended section to learn more.

[0098] Thus, when it is determined that a user is committed to running a particular application, the recommendation engine 720 may recommend a particular major engine version, minor version, patch set, specific patch set, OS / DB configuration, etc. that is known (or inferred based on the activities of other users) to be applicable to that application. Alternatively, if the user needs to meet a certain compliance program, the recommendation engine 720 may provide recommendations that will bring them into compliance with that program - e.g., a particular feature to enable, a particular patch set to apply, etc.

[0099] The recommendation may include a comparison with one or more existing engine versions, for example, via analysis of the user's CDEV input and CDEV metadata 810. For example, a user may want to know whether the engine version they are building is a superset of patches or vulnerability fixes compared to another engine version. In some cases, if the target engine version is incompatible with the source engine version or is not a superset of the source engine version, the upgrade may fail. For example, the lack of patches related to daylight saving time updates (for example, for Oracle (TM) databases) may not result in an invalid engine version, but may cause the upgrade to fail. In other cases, the user may have encountered a specific vulnerability and want to ensure that when it is upgraded, they have not missed applying vulnerability fixes in the target engine version. The source engine version for comparison may be specified at build time, or may be included in a strategy related to the build. In some cases, a large number of existing engine versions may be used for comparison, or the user may limit the engine version for comparison based on the expected application of the engine version being built, such as by using tags / metadata. In some cases, the implementation scheme may allow the successful construction of a new engine version, but may not create an "upgrade path" for a source engine version that is incompatible with the new target engine version.

[0100] Fig.10 1000 (or other processes described herein, or variations and / or combinations thereof) are performed under the control of one or more computer systems configured with executable instructions and implemented as codes (e.g., executable instructions, one or more computer programs, or one or more applications) executed together on one or more processors. The code is stored on a computer-readable storage medium, for example, in the form of a computer program including instructions that can be executed by one or more processors. The computer-readable storage medium is non-transitory. In some embodiments, one or more (or all) of the operations 1000 are performed by the database customization service 108 of other figures.

[0101] Operation 1000 includes receiving a request to create a custom database engine version at block 1002, and obtaining one or more database installation files at block 1004. Operation 1000 also includes creating a custom database engine version based on the one or more database installation files and use of a computing instance at block 1006, and validating the custom database engine version as satisfying the request and valid for launching a database instance at block 1008. Operation 1000 also includes providing the custom database engine version to a user at block 1010, or launching a database instance based on the custom database engine version.

[0102] In some embodiments, the database instance executes in a shared management environment within a multi-tenant provider network, allowing users to have administrative access to the compute instances of the database instance while control plane entities of the provider network also have direct administrative access to the compute instances.

[0103] In some embodiments, a request to create a custom database engine version is initiated in association with a first user account of a multi-tenant provider network, and the operation further includes: receiving a request to launch a database instance, the request including an identifier of the custom database engine version and initiated in association with a second user account of the multi-tenant provider network; and launching the database instance.

[0104] In some embodiments, the request includes a resource identifier associated with a storage location where one or more database installation files are located; and obtaining the one or more database installation files includes transmitting a request to obtain the one or more database installation files based on the use of the resource identifier. In some embodiments, the request also includes at least one of a manifest file or an identifier of a second storage location where the manifest file is located, wherein the manifest file identifies at least one of: one or more database installation files; a database engine version; a set of features to be enabled or disabled; or compliance program information.

[0105] In some embodiments, the request includes at least one of: an identifier of a type or configuration of a computing instance used to build or validate the database engine; or an identifier of an operating system to be executed by the computing instance.

[0106] In some embodiments, creation of the custom database engine version includes generating an image of the compute instance or a snapshot of a storage volume utilized by the compute instance, wherein the snapshot includes a point-in-time copy of data of the storage volume and the custom database engine version includes the image or the snapshot.

[0107] In some embodiments, validating the custom database engine version includes creating a database instance based on the use of the custom database engine version, which includes attaching the storage volume of the custom database engine version to a second computing instance or utilizing an image. In some embodiments, validating the custom database engine version also includes performing tests involving the database instance; and determining the results of the tests. In some embodiments, the tests include at least one of the following: determining that the version of the database engine matches the requested database engine version; determining that the database engine has successfully installed all patches or vulnerability fixes from one or more database installation files; determining that additional or dependent software has been installed; determining that the operating system is compatible with the requested database engine version or is certified for the requested database engine version; determining that the database engine or operating system has a set of requested features enabled or disabled; determining that the database engine or operating system meets the requirements of the compliance program; determining that the database engine or operating system functions properly; determining that the database engine or operating system meets a performance threshold; or determining that the database engine or operating system remains stable over a period of time.

[0108] In some embodiments, the operations also include performing one or more validation tests prior to creation of the custom database engine version, the one or more validation tests including at least one of the following: determining whether the one or more database installation files are authentic; determining whether the one or more database installation files include a set of features requested to be enabled; determining whether any of the one or more database installation files are marked as being replaced by an alternative database installation file; determining whether any of the one or more database installation files are marked as having functional, performance, or stability issues; or determining whether a configuration associated with the request is valid.

[0109] Fig.11 1100 (or other processes described herein, or variations and / or combinations thereof) are performed under the control of one or more computer systems configured with executable instructions and implemented as codes (e.g., executable instructions, one or more computer programs, or one or more applications) that are executed together on one or more processors. The code is stored on a computer-readable storage medium, for example, in the form of a computer program that includes instructions that can be executed by one or more processors. The computer-readable storage medium is non-transitory. In some embodiments, one or more (or all) of the operations 1100 are performed by the database customization service 108 of other figures.

[0110] Operation 1100 includes obtaining a policy specified by a first user to control creation of a custom database engine version within a provider network at block 1102, and receiving a request to create a custom database engine version at block 1104, wherein the request is initiated on behalf of a second user. Operation 1100 also includes determining at block 1106 that the user-specified policy has been violated, and denying the request to create the custom database engine version or notifying the first user or the second user of the violation of the user-specified policy at block 1108.

[0111] In some embodiments, the policy indicates that any database instance created based on the custom database engine version must have a certain feature enabled or must have the feature disabled.

[0112] In some embodiments, the policy indicates that any database instance created based on the custom database engine version must utilize an operating system or database engine that satisfies the conditions of the policy. In some embodiments, the conditions specify that the operating system or database engine: is a version from a set of approved versions; has a feature enabled or disabled; is released by a vendor from a set of approved vendors; is open source; has a license from a set of approved licenses; is patched with a specified patch or bug fix; does not have any known security defects of a certain type or severity; is not missing any updates or patches of a certain type that have become available within a threshold amount of time; or meets the requirements of a compliance program.

[0113] In some embodiments, the policy will further control the continued execution of the database instance launched using the custom database engine version, and operation 1100 also includes: receiving a second request to create a custom database engine version, wherein the second request identifies an updated configuration; creating the custom database engine version according to the updated configuration; determining that the database instance launched based on the use of the custom database engine version now violates the policy; and performing an action in response to determining that the custom database engine version now violates the policy. In some embodiments, the action includes: identifying an upgrade of the database instance that will make the database instance comply with the policy again; and arranging to upgrade the database instance or providing a notification indicating the availability of the upgrade based on the identified upgrade. In some embodiments, the action includes: placing the database instance in network isolation, wherein when in network isolation, at least some network connections of the database instance are eliminated or restricted; or terminating the database instance. In some embodiments, the policy indicates that any executing database instance launched based on the use of the custom database engine version will be updated or patched within a threshold amount of time after a particular type of update or patch is released. In some embodiments, the database instance is in violation of policy due to one of: a change in some aspect of the policy (e.g., a more stringent requirement is implemented), a new security defect is published that affects the database instance, or a severity score of an existing security defect is changed to a new value that causes the database instance to now be in violation of policy. In some embodiments, the database instance executes in an internal environment of an organization that is different from the provider network, and in some embodiments, the database instance executes in a self-managed manner via a hardware virtualization service of the provider network.

[0114] Fig.12 1200 (or other processes described herein, or variations and / or combinations thereof) are performed under the control of one or more computer systems configured with executable instructions and implemented as codes (e.g., executable instructions, one or more computer programs, or one or more applications) that are executed together on one or more processors. The code is stored on a computer-readable storage medium, for example, in the form of a computer program that includes instructions that can be executed by one or more processors. The computer-readable storage medium is non-transitory. In some embodiments, one or more (or all) of the operations 1200 are performed by the database customization service 108 of other figures.

[0115] Operation 1200 includes receiving a request to create a customized database engine version at block 1202, the request identifying a first configuration, and automatically generating recommended modifications to the first configuration based at least in part on an analysis of the first configuration at block 1204. Operation 1200 also includes causing the recommended modifications to be presented via a user interface at block 1206, and generating the customized database engine version based on a second configuration including the recommended modifications at block 1208, wherein the second configuration is different from the first configuration.

[0116] In some embodiments, the generation of the recommended modification is further based on an identifier of an application to be used with the database instance launched based on the custom database engine version. In some embodiments, operation 1200 also includes: obtaining an identifier of the application from within the request; or inferring an identifier of the application based on an analysis of a database installation file associated with the request.

[0117] In some embodiments, the recommended modifications include at least one of the following: a recommended operating system type, version, or configuration; or a recommended database engine type, version, or configuration. In some embodiments, the recommended modifications include at least one of the following: a recommended software update or patch to be applied to the operating system or database engine; or a recommended feature or extension to be enabled or disabled for the operating system or database engine.

[0118] In some embodiments, the recommended modification includes applying a software patch, adding an additional installation file, or enabling a database engine extension or feature. In some embodiments, automatically generating the recommended modification includes: identifying a third configuration based on the use of the first configuration; and comparing the first configuration to the third configuration. In some embodiments, automatically generating the recommended modification includes: identifying a feature or extension associated with the first configuration; and determining that the first configuration does not specify a software patch associated with the feature or extension, wherein the recommended modification includes the addition of the software patch.

[0119] In some embodiments, automatically generating recommended modifications to the first configuration also includes: determining that the first configuration does not meet compliance standards, wherein if applied to the first configuration, the recommended modifications would bring the custom database engine version or a database instance launched based on use of the custom database engine version into compliance with the compliance standards.

[0120] In some embodiments, automatically generating recommended modifications to a configuration based at least in part on an analysis of the configuration includes: comparing the first configuration to a third configuration of a second custom database engine version; and determining that a set of patches or bug fixes specified by the first configuration does not include at least one patch or bug fix of the third configuration, wherein the recommended modifications include adding the at least one patch or bug fix to the first configuration.

[0121] Fig.13 An example provider network (or "service provider system") environment is shown according to some embodiments. Provider network 1300 may provide resource virtualization to customers via one or more virtualization services 1310, which allow customers to purchase, lease, or otherwise obtain instances 1312 of virtualized resources (including, but not limited to, computing resources and storage resources) implemented on devices within one or more provider networks in one or more data centers. A local Internet Protocol (IP) address 1316 may be associated with resource instance 1312; the local IP address is the internal network address of the resource instance 1312 on provider network 1300. In some embodiments, provider network 1300 may also provide public IP addresses 1314 and / or public IP address ranges (e.g., Internet Protocol version 4 (IPv4) or Internet Protocol version 6 (IPv6) addresses) that customers can obtain from provider 1300.

[0122] Conventionally, the provider network 1300 may allow a customer of the service provider (e.g., a customer operating one or more customer networks 1350A-1350C (or "client networks") including one or more customer devices 1352) via the virtualization service 1310 to dynamically associate at least some of the public IP addresses 1314 assigned or allocated to the customer with a specific resource instance 1312 assigned to the customer. The provider network 1300 may also allow a customer to remap a public IP address 1314 previously mapped to one virtualized computing resource instance 1312 assigned to the customer to another virtualized computing resource instance 1312 also assigned to the customer. Using the virtualized computing resource instances 1312 and public IP addresses 1314 provided by the service provider, a customer of the service provider (such as an operator of the customer networks 1350A-1350C) may, for example, implement customer-specific applications and present the customer's applications on an intermediate network 1340 such as the Internet. Other network entities 1320 on the intermediate network 1340 may then generate traffic destined for the destination public IP address 1314 published by the customer networks 1350A-1350C; the traffic is routed to the service provider data center, and there, via the network underlay, is routed to the local IP address 1316 of the virtualized computing resource instance 1312 that is currently mapped to the destination public IP address 1314. Similarly, response traffic from the virtualized computing resource instance 1312 may be routed back to the source entity 1320 on the intermediate network 1340 via the network underlay.

[0123] As used herein, a local IP address refers to an internal or "private" network address of a resource instance, for example, in a provider network. A local IP address may be within an address block reserved by Request for Comments (RFC) 1918 of the Internet Engineering Task Force (IETF) and / or have an address format specified by IETF RFC 4193, and may be variable within a provider network. Network traffic originating outside the provider network is not routed directly to a local IP address; instead, traffic uses a public IP address that is mapped to the local IP address of the resource instance. The provider network may include a networking device or appliance that provides network address translation (NAT) or similar functionality to perform mappings from public IP addresses to local IP addresses and from local IP addresses to public IP addresses.

[0124] A public IP address is an Internet-mutable network address assigned to a resource instance by a service provider or customer. Traffic routed to a public IP address is translated, for example, via 1:1 NAT, and forwarded to the corresponding local IP address of the resource instance.

[0125] Some public IP addresses may be assigned to specific resource instances by the provider network infrastructure; these public IP addresses may be referred to as standard public IP addresses, or simply standard IP addresses. In some embodiments, the mapping of standard IP addresses of resource instances to local IP addresses is the default startup configuration for all resource instance types.

[0126] At least some public IP addresses may be assigned to or obtained by customers of the provider network 1300; then, the customer may assign the public IP address assigned to it to a specific resource instance assigned to the customer. These public IP addresses may be referred to as customer public IP addresses, or simply customer IP addresses. Rather than being assigned to a resource instance by the provider network 1300 as in the case of a standard IP address, a customer IP address may be assigned to a resource instance by the customer, for example, via an API provided by a service provider. Unlike a standard IP address, a customer IP address is assigned to a customer account and may be remapped to other resource instances by the corresponding customer as needed or desired. A customer IP address is associated with a customer account, not a specific resource instance, and the customer controls the IP address until the customer chooses to release the IP address. Unlike conventional static IP addresses, a customer IP address allows a customer to mask a resource instance or availability zone failure by remapping the customer's public IP address to any resource instance associated with the customer account. For example, a customer IP address enables a customer to solve a problem with a customer's resource instance or software by remapping the customer IP address to an alternative resource instance.

[0127] Fig.1414 is a block diagram of an example provider network environment that provides storage services and hardware virtualization services to customers according to some embodiments. Hardware virtualization service 1420 provides multiple computing resources 1424 (e.g., computing instances 1425, such as VMs) to customers. Computing resources 1424 can be provided as a service to customers of provider network 1400 (e.g., customers implementing customer network 1450), for example. Each computing resource 1424 can be provided with one or more local IP addresses. Provider network 1400 can be configured to route packets from the local IP addresses of computing resources 1424 to public Internet destinations and to route packets from public Internet sources to the local IP addresses of computing resources 1424.

[0128] The provider network 1400 may enable a customer network 1450 coupled to the intermediate network 1440, for example, via a local network 1456, to implement a virtual computing system 1492 via a hardware virtualization service 1420 coupled to the intermediate network 1440 and the provider network 1400. In some embodiments, the hardware virtualization service 1420 may provide one or more APIs 1402, such as web service interfaces, via which the customer network 1450 may access functionality provided by the hardware virtualization service 1420, for example, via a console 1494 (e.g., a web-based application, a standalone application, a mobile application, etc.) of a customer device 1490. In some embodiments, at the provider network 1400, each virtual computing system 1492 at the customer network 1450 may correspond to a computing resource 1424 that is rented, leased, or otherwise provided to the customer network 1450.

[0129] From an instance of a virtual computing system 1492 and / or another customer device 1490 (e.g., via a console 1494), a customer may access functionality of a storage service 1410, e.g., via one or more APIs 1402, to access and store data from storage resources 1418A-1418N (e.g., folders or "buckets," virtualized volumes, databases, etc.) of a virtual data store 1416 provided by a provider network 1400. In some embodiments, a virtualized data storage gateway (not shown) may be located at the customer network 1450, which may cache at least some data locally (e.g., frequently accessed data or critical data) and may communicate with the storage service 1410 via one or more communication channels to upload new or modified data from a local cache so that a primary storage area for the data (the virtualized data store 1416) is maintained. In some embodiments, a user via a virtual computing system 1492 and / or another client device 1490 may mount and access virtual data storage 1416 volumes via a storage service 1410 acting as a storage virtualization service, and these volumes may appear to the user as local (virtualized) storage devices 1498 .

[0130] Although Fig.14 1400, but the virtualization service may also be accessed from a resource instance within the provider network 1400 via API 1402. For example, a customer, device service provider, or other entity may access the virtualization service via API 1402 from within a corresponding virtual network on the provider network 1400 to request allocation of one or more resource instances within the virtual network or within another virtual network.

[0131] Descriptive System

[0132] In some embodiments, a system implementing part or all of the techniques described herein may include a general-purpose computer system (such as Fig.15 The computer system 1500 shown in the figure is a general purpose computer system that includes or is configured to access one or more computer accessible media. In the illustrated embodiment, the computer system 1500 includes one or more processors 1510 coupled to a system memory 1520 via an input / output (I / O) interface 1530. The computer system 1500 also includes a network interface 1540 coupled to the I / O interface 1530. Although Fig.15 Computer system 1500 is shown as a single computing device, but in various embodiments, computer system 1500 may include one computing device or any number of computing devices configured to work together as a single computer system 1500 .

[0133] In various embodiments, computer system 1500 may be a uniprocessor system including one processor 1510, or a multiprocessor system including several processors 1510 (e.g., two, four, eight, or another suitable number). Processor 1510 may be any suitable processor capable of executing instructions. For example, in various embodiments, processor 1510 may be a general-purpose processor or an embedded processor that implements any of a variety of instruction set architectures (ISAs), such as x86, ARM, PowerPC, SPARC, or MIPS ISAs, or any other suitable ISAs. In a multiprocessor system, each of processors 1510 may typically, but not necessarily, implement the same ISA.

[0134] System memory 1520 may store instructions and data that may be accessed by processor 1510. In various embodiments, system memory 1520 may be implemented using any suitable memory technology, such as random access memory (RAM), static RAM (SRAM), synchronous dynamic RAM (SDRAM), non-volatile / flash-type memory, or any other type of memory. In the illustrated embodiment, program instructions and data that implement one or more desired functions (such as those methods, techniques, and data described above) are shown as stored within system memory 1520 as database customization service code 1525 (e.g., executable to fully or partially implement database customization service 108) and data 1526.

[0135] In some embodiments, the I / O interface 1530 may be configured to coordinate I / O traffic between the processor 1510, the system memory 1520, and any peripheral devices in the device, including the network interface 1540 and / or other peripheral interfaces (not shown). In some embodiments, the I / O interface 1530 may perform any necessary protocol, timing, or other data transformations to convert data signals from one component (e.g., the system memory 1520) into a format suitable for use by another component (e.g., the processor 1510). In some embodiments, for example, the I / O interface 1530 may include support for devices attached through various types of peripheral buses, such as a variation of the Peripheral Component Interconnect (PCI) bus standard or the Universal Serial Bus (USB) standard. In some embodiments, for example, the functionality of the I / O interface 1530 may be split into two or more separate components, such as a north bridge and a south bridge. In addition, in some embodiments, some or all of the functionality of the I / O interface 1530 (such as an interface to the system memory 1520) may be directly incorporated into the processor 1510.

[0136] For example, the network interface 1540 may be configured to allow the computer system 1500 to communicate with other devices 1560 attached to one or more networks 1550 (such as Figure 1 In various embodiments, network interface 1540 may support communication via any suitable wired or wireless general purpose data network, such as various types of Ethernet networks, for example. Additionally, network interface 1540 may support communication via a telecommunications / telephone network, such as an analog voice network or a digital fiber optic communications network, via a storage area network (SAN), such as a Fibre Channel SAN, and / or via any other suitable type of network and / or protocol.

[0137] In some embodiments, computer system 1500 includes one or more offload cards 1570A or 1570B (including one or more processors 1575, and possibly one or more network interfaces 1540) connected using I / O interface 1530 (e.g., a bus implementing a version of the Peripheral Component Interconnect Express (PCI-E) standard, or another interconnect such as QuickPath Interconnect (QPI) or UltraPath Interconnect (UPI)). For example, in some embodiments, computer system 1500 may act as a host electronic device hosting computing resources such as computing instances (e.g., operating as part of a hardware virtualization service), and one or more offload cards 1570A or 1570B execute a virtualization manager that can manage computing instances executing on the host electronic device. As an example, in some embodiments, offload card 1570A or 1570B may perform computing instance management operations, such as pausing and / or unpausing computing instances, starting and / or terminating computing instances, performing memory transfer / copy operations, etc. In some embodiments, these management operations may be performed by the offload card 1570A or 1570B in cooperation with hypervisors (e.g., based on requests from the hypervisors) executed by the other processors 1510A-1510N of the computer system 1500. However, in some embodiments, the virtualization manager implemented by the offload card 1570A or 1570B may adapt to requests from other entities (e.g., from the computing instances themselves) and may not cooperate with (or serve) any individual hypervisor.

[0138] In some embodiments, system memory 1520 may be an embodiment of a computer-accessible medium configured to store program instructions and data as described above. However, in other embodiments, program instructions and / or data may be received, sent, or stored on different types of computer-accessible media. In general, computer-accessible media may include any non-transitory storage media or memory media, such as magnetic or optical media, such as a disk or DVD / CD coupled to computer system 1500 via I / O interface 1530. Non-transitory computer-accessible storage media may also include any volatile or non-volatile media that may be included in some embodiments of computer system 1500 as system memory 1520 or another type of memory, such as RAM (e.g., SDRAM, double data rate (DDR) SDRAM, SRAM, etc.), read-only memory (ROM), etc. In addition, computer-accessible media may include a transmission medium or a signal transmitted via a communication medium (such as a network and / or a wireless link), such as an electrical signal, an electromagnetic signal, or a digital signal, and the communication medium may be implemented via network interface 1540.

[0139] Various embodiments discussed or proposed herein can be implemented in a variety of operating environments, in some cases, the operating environment may include one or more user computers, computing devices or processing devices that can be used to operate any of many applications. User devices or client devices may include any of many general personal computers, such as desktop computers or laptop computers running standard operating systems, and cellular devices, wireless devices and handheld devices that run mobile software and can support many networking and messaging protocols. Such a system may also include many workstations, which run various commercially available operating systems and any of other known applications for purposes such as development and database management. These devices may also include other electronic devices, such as virtual terminals, thin clients, game systems and / or other devices that can communicate via a network.

[0140] Most embodiments use at least one network familiar to those skilled in the art to support communications using any of a variety of widely available protocols, such as Transmission Control Protocol / Internet Protocol (TCP / IP), File Transfer Protocol (FTP), Universal Plug and Play (UPnP), Network File System (NFS), Common Internet File System (CIFS), Extensible Messaging and Presence Protocol (XMPP), AppleTalk, etc. The network may include, for example, a local area network (LAN), a wide area network (WAN), a virtual private network (VPN), the Internet, an intranet, an extranet, a public switched telephone network (PSTN), an infrared network, a wireless network, and any combination thereof.

[0141] In embodiments using a web server, the web server may run any of a variety of server or middle-tier applications, including HTTP servers, file transfer protocol (FTP) servers, common gateway interface (CGI) servers, data servers, Java servers, business application servers, etc. The server may also be capable of executing programs or scripts in response to requests from user devices, such as by executing a program that may be implemented in any programming language (such as The server may include one or more web applications written in one or more scripts or programs in C, C#, or C++, or any scripting language such as Perl, Python, PHP, or TCL, and combinations thereof. The server may also include a database server, including but not limited to commercially available database servers from Oracle (R), Microsoft (R), Sybase (R), IBM (R), etc. The database server may be relational or non-relational (e.g., "NoSQL"), distributed or non-distributed, etc.

[0142] The environment disclosed herein may include various data storage areas and other memories and storage media as discussed above. These may reside in various locations, such as on storage media residing locally (and / or residing therein) on one or more computers, or on storage media residing away from any or all computers on the network. In a specific set of embodiments, information may reside in a storage area network (SAN) familiar to those skilled in the art. Similarly, any necessary files for performing functions belonging to computers, servers or other network devices may be stored locally and / or remotely as appropriate. In the case where the system includes a computerized device, each such device may include hardware elements that may be electrically coupled via a bus, the elements including, for example, at least one central processing unit (CPU), at least one input device (e.g., mouse, keyboard, controller, touch screen or keypad) and / or at least one output device (e.g., display device, printer or speaker). Such a system may also include one or more storage devices, such as disk drives, optical storage devices and solid-state storage devices (such as random access memory (RAM) or read-only memory (ROM)), as well as removable media devices, memory cards, flash memory cards, etc.

[0143] Such devices may also include a computer-readable storage medium reader, a communication device (e.g., a modem, a network card (wireless or wired), an infrared communication device, etc.), and a working memory as described above. A computer-readable storage medium reader may be connected to or configured to receive a computer-readable storage medium, which represents a remote, local, fixed and / or removable storage device and a storage medium for temporarily and / or longer accommodating, storing, transmitting and retrieving computer-readable information. The system and various devices will also typically include a number of software applications, modules, services or other elements located within at least one working memory device, including an operating system and applications, such as a client application or a web browser. It should be understood that alternative embodiments may have many variations different from those described above. For example, custom hardware may also be used, and / or specific elements may be implemented in hardware, software (including portable software, such as applets), or both. In addition, connections with other computing devices (such as network input / output devices) may be employed.

[0144] Storage media and computer-readable media for containing code or code portions may include any suitable media known or used in the art, including storage media and communication media, such as but not limited to volatile and non-volatile media, removable and non-removable media implemented in any method or technology to store and / or transmit information (such as computer-readable instructions, data structures, program modules or other data), including RAM, ROM, electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, compact disk-read-only memory (CD-ROM), digital versatile disk (DVD) or other optical storage device, magnetic cassette, magnetic tape, magnetic disk storage device or other magnetic storage device or any other medium that can be used to store the desired information and can be accessed by the system device. Based on the present disclosure and the teachings provided herein, ordinary technicians in the art will understand other ways and / or methods of implementing various embodiments.

[0145] In the foregoing description, various embodiments are described. For explanatory purposes, specific configurations and details are set forth in order to provide a thorough understanding of the embodiments. However, it will also be apparent to those skilled in the art that the embodiments may be practiced without these specific details. In addition, in order not to obscure the described embodiments, well-known features may be omitted or simplified.

[0146] Bracketed text and boxes with dashed borders (e.g., large dashes, small dashes, dot dashes, and dots) are used herein to illustrate optional operations that add additional features to some embodiments. However, this notation should not be taken to mean that these are the only options or optional operations, and / or that in some embodiments, boxes with solid borders are not optional.

[0147] In various embodiments, reference numerals with suffix letters (e.g., 1418A-1418N) may be used to indicate that there may be one or more instances of the referenced entity, and when there are multiple instances, each instance need not be identical, but may instead share some general features or function in a common manner. Furthermore, unless expressly indicated to the contrary, the particular suffix used is not meant to imply that there is a particular amount of the entity. Thus, in various embodiments, two entities using the same or different suffix letters may or may not have the same number of instances.

[0148] References to "one embodiment," "an embodiment," "an example embodiment," etc. indicate that the described embodiment may include a particular feature, structure, or characteristic, but every embodiment may not necessarily include the particular feature, structure, or characteristic. Furthermore, such phrases are not necessarily referring to the same embodiment. Furthermore, when a particular feature, structure, or characteristic is described in conjunction with an embodiment, it should be understood that it is within the knowledge of those skilled in the art to implement such feature, structure, or characteristic in conjunction with other embodiments, whether or not explicitly described.

[0149] Furthermore, in the various embodiments described above, unless specifically indicated otherwise, disjunctive language such as the phrase "at least one of A, B, or C" is intended to be understood to mean A, B, or C, or any combination thereof (e.g., A, B, and / or C). Similarly, language such as "at least one or more of A, B, and C" (or "one or more of A, B, and C") is intended to be understood to mean A, B, or C, or any combination thereof (e.g., A, B, and / or C). Thus, disjunctive language is neither intended nor should be understood to imply that a given embodiment requires that at least one of A, at least one of B, and at least one of C each be present.

[0150] Unless expressly stated otherwise, articles such as "a" or "an" should generally be interpreted as including one or more of the described items. Thus, phrases such as "a device configured to" or "computing device" are intended to include one or more of the recited devices. The one or more recited devices may be collectively configured to perform the recited operations. For example, "a processor configured to perform operations A, B, and C" may include a first processor configured to perform operation A working together with a second processor configured to perform operations B and C.

[0151] At least some embodiments of the disclosed technology may be described in terms of the following:

[0152] 1. A computer-implemented method, the method comprising:

[0153] receiving one or more database installation files at a storage service of a multi-tenant provider network;

[0154] storing the one or more database installation files at a storage location;

[0155] receiving, at a managed database service of the multi-tenant provider network, a request to create a custom database engine version, the request including an identifier of the storage location;

[0156] Obtaining the one or more database installation files from the storage location;

[0157] creating the customized database engine version based on the use of the computing instance and the one or more database installation files, wherein the creating comprises generating an image of the computing instance or a point-in-time snapshot of a storage volume used by the computing instance;

[0158] verifying that the custom database engine version satisfies the request and is valid for launching a database instance;

[0159] Updating a data structure to indicate that the custom database engine version can be used to start a database instance;

[0160] receiving a request to start a database, the request including an identifier of the custom database engine version; and

[0161] A database instance is started based on the database engine version, wherein the starting includes starting a second computing instance using the image or attaching the storage volume to the second computing instance using the point-in-time snapshot.

[0162] 2. The computer-implemented method of clause 1, further comprising:

[0163] receiving a request allowing a user to manage the second computing instance;

[0164] suspending one or more management operations for a period of time; and

[0165] After the time period or upon receiving a request to end user management of the second computing instance, the one or more management operations are enabled.

[0166] 3. A computer-implemented method as described in any of clauses 1-2, wherein:

[0167] The request further includes an identifier of a manifest file or a second storage location where the manifest file is located, wherein the manifest file identifies an ordering associated with a plurality of patches to be applied during generation of the database, and

[0168] Wherein said generating of said database comprises applying said plurality of patches according to said ordering.

[0169] 4. A computer-implemented method, the method comprising:

[0170] receiving requests to create custom database engine versions;

[0171] Obtain one or more database installation files;

[0172] creating the customized database engine version based on the one or more database installation files and use of the computing instance;

[0173] verifying that the custom database engine version satisfies the request and is valid for launching a database instance; and

[0174] The customized database engine version is provided to the user, or a database instance is started based on the customized database engine version.

[0175] 5. The computer-implemented method of clause 4, wherein the request to create the custom database engine version is initiated in association with a first user account of a multi-tenant provider network, and wherein the method further comprises:

[0176] receiving a request to launch the database instance, the request including an identifier of the custom database engine version and initiated in association with a second user account of the multi-tenant provider network; and

[0177] Start the database instance.

[0178] 6. A computer-implemented method as described in any of clauses 4-5, wherein the database instance is executed in a shared management environment within a multi-tenant provider network, thereby allowing a user to have administrative access to a computing instance of the database instance, while a control plane entity of the provider network also has direct administrative access to the computing instance.

[0179] 7. A computer-implemented method as described in any of clauses 4-6, wherein:

[0180] The request includes a resource identifier associated with a storage location where the one or more database installation files are located; and

[0181] Obtaining one or more database installation files includes transmitting a request to obtain the one or more database installation files based on use of the resource identifier.

[0182] 8. The computer-implemented method of clause 7, wherein:

[0183] The request also includes at least one of a manifest file or an identifier of a second storage location where the manifest file is located, wherein the manifest file identifies at least one of:

[0184] the one or more database installation files;

[0185] Database engine version;

[0186] a set of features to enable or disable; or

[0187] Compliance Program Information.

[0188] 9. The computer-implemented method of any of clauses 4-8, wherein the request comprises at least one of:

[0189] An identifier of the type or configuration of a compute instance used to build or validate a database engine; or

[0190] An identifier of the operating system to be executed by the compute instance.

[0191] 10. The computer-implemented method of any of clauses 4-9, wherein the creation of the custom database engine version comprises:

[0192] generating an image of the computing instance or a snapshot of a storage volume utilized by the computing instance, wherein the snapshot comprises a point-in-time copy of data of the storage volume, and

[0193] The customized database engine version includes the image or the snapshot.

[0194] 11. The computer-implemented method of any of clauses 4-10, wherein validating the custom database engine version comprises:

[0195] A database instance is created based on use of the custom database engine version, which includes attaching a storage volume of the custom database engine version to a second compute instance or utilization image.

[0196] 12. The computer-implemented method of clause 11, wherein validating the custom database engine version further comprises:

[0197] executing tests involving the database instance; and

[0198] The results of the test are determined.

[0199] 13. The computer-implemented method of clause 12, wherein the testing comprises at least one of:

[0200] Determining that the database engine has successfully installed all patches from the one or more database installation files;

[0201] determining that the database engine or the operating system causes a set of requested features to be enabled or disabled;

[0202] Determining that the database engine or the operating system meets the requirements of the compliance plan;

[0203] determining that the database engine or the operating system meets a performance threshold; or

[0204] It is determined that the database engine or the operating system remains stable over a period of time.

[0205] 14. The computer-implemented method of any of clauses 4-13, further comprising:

[0206] One or more validation tests are performed prior to said creating of said custom database engine version, said one or more validation tests comprising at least one of:

[0207] determining whether the one or more database installation files are authentic;

[0208] determining whether the one or more database installation files include code for requesting a set of features to be enabled;

[0209] determining whether any of the one or more database installation files is flagged as having functionality, performance, or stability issues; or

[0210] A determination is made that a configuration associated with the request is valid.

[0211] 15. A system, comprising:

[0212] a first one or more electronic devices configured to implement a storage service in a multi-tenant provider network, the storage service configured to receive and store one or more database installation files at a storage location associated with a user account; and

[0213] second one or more electronic devices, the second one or more electronic devices being configured to implement a database customization service in the multi-tenant provider network, the database customization service comprising instructions that, when executed, cause the database customization service to:

[0214] receiving requests to create custom database engine versions;

[0215] Obtaining the one or more database installation files from the storage service;

[0216] creating the customized database engine version based on use of the computing instance and the one or more database installation files;

[0217] verifying that the custom database engine version satisfies the request and is valid for launching a database instance; and

[0218] The customized database engine version is provided to the user, or a database instance is started based on the customized database engine version.

[0219] 16. A system as described in clause 15, wherein the database customization service executes the database instance in a shared management environment within the provider network, thereby allowing a user to have administrative access to the computing instance of the database instance, while the control plane entity of the provider network also has direct administrative access to the computing instance.

[0220] 17. The system of any of clauses 15-16, wherein the request includes an identifier of the storage location where the one or more database installation files are stored.

[0221] 18. In a system as described in clause 17, the request also includes an identifier of a manifest file or a second storage location where the manifest file is located, wherein the manifest file identifies at least one of: the one or more database installation files; a database engine version; a set of features to be enabled or disabled; or compliance program information.

[0222] 19. The system of any of clauses 15-18, wherein the request comprises at least one of:

[0223] An identifier of the type or configuration of a compute instance used to build or validate a database engine; or

[0224] An identifier of the operating system to be executed by the compute instance.

[0225] 20. The system of any of clauses 15-19, wherein as part of said creating of said customized database engine version, database customization is to:

[0226] generating an image of the computing instance or a snapshot of a storage volume utilized by the computing instance, wherein the snapshot comprises a point-in-time copy of data of the storage volume, and

[0227] The customized database engine version includes the image or the snapshot.

[0228] 21. A computer-implemented method, the method comprising:

[0229] receiving a policy specified by a first user to control creation of a custom database engine version within a provider network by other users belonging to the same organization as the first user, and further to control ongoing execution of database instances launched in the provider network based on the custom database engine version;

[0230] receiving a request to create a custom database engine version, wherein the request is initiated by a second user on behalf of the organization and identifies a configuration associated with a database engine;

[0231] identifying the policy as applicable to the request based on the request;

[0232] evaluating the policy, which includes determining that the configuration violates the user-specified policy; and

[0233] The request to create the custom database engine version is denied or the first user or the second user is notified of the violation of the user-specified policy.

[0234] 22. The computer-implemented method of clause 21, wherein the policy indicates that any database instance created based on the custom database engine version must utilize an operating system or database engine that satisfies the conditions of the policy.

[0235] 23. The computer-implemented method of clause 22, wherein the condition specifies that the operating system or the database engine:

[0236] is a version from a set of approved versions;

[0237] Causes a feature to be enabled or disabled;

[0238] Issued by a supplier from a group of approved suppliers;

[0239] It is open source;

[0240] Possess one of a group of approved licenses;

[0241] Patched with specified patches or bug fixes;

[0242] There are no known security defects of a particular type or severity;

[0243] not lacking any updates or patches of a particular type that have become available within the threshold amount of time; or

[0244] Meet compliance program requirements.

[0245] 24. A computer-implemented method, the method comprising:

[0246] obtaining a first user-specified policy to control creation of a custom database engine version within a provider network;

[0247] receiving a request to create a custom database engine version, wherein the request is initiated on behalf of a second user;

[0248] determining that the user-specified policy has been violated; and

[0249] The request to create the custom database engine version is denied or the first user or the second user is notified of the violation of the user-specified policy.

[0250] 25. The computer-implemented method of clause 24, wherein the policy indicates that any database instance created based on the custom database engine version must have a feature enabled or must have the feature disabled.

[0251] 26. The computer-implemented method of any of clauses 24-25, wherein the policy indicates that any database instance created based on the custom database engine version must utilize an operating system or database engine that satisfies the conditions of the policy.

[0252] 27. The computer-implemented method of clause 26, wherein the condition specifies that the operating system or the database engine:

[0253] is a version from a set of approved versions;

[0254] Causes a feature to be enabled or disabled;

[0255] Issued by a supplier from a group of approved suppliers;

[0256] Possess one of a group of approved licenses;

[0257] Patching with specified patch;

[0258] There are no known security defects of a particular type or severity;

[0259] not lacking any updates or patches of a particular type that have become available within the threshold amount of time; or

[0260] Meet compliance program requirements.

[0261] 28. The computer-implemented method of any of clauses 24-27, wherein the policy further controls continued execution of a database instance launched using the custom database engine version, and wherein the method further comprises:

[0262] receiving a second request to create the custom database engine version, wherein the second request identifies an updated configuration;

[0263] Creating the custom database engine version according to the updated configuration;

[0264] determining that a database instance launched based on use of the custom database engine version now violates the policy; and

[0265] An action is performed in response to the determining that the customized database engine version now violates the policy.

[0266] 29. The computer-implemented method of clause 28, wherein the actions comprise:

[0267] identifying an upgrade to the database instance that will bring the database instance into compliance with the policy again; and

[0268] An upgrade of the database instance is scheduled based on the identified upgrade or a notification is provided indicating the availability of the upgrade.

[0269] 30. The computer-implemented method of clause 28, wherein the actions comprise:

[0270] placing the database instance in network isolation, wherein while in the network isolation, at least some network connections of the database instance are eliminated or restricted; or

[0271] Terminate the database instance.

[0272] 31. The computer-implemented method of any of clauses 28-30, wherein the policy indicates that any executing database instance launched based on use of the custom database engine version is to be updated or patched within a threshold amount of time after a particular type of update or patch is released.

[0273] 32. The computer-implemented method of any of clauses 28-31, wherein the database instance violates the policy due to one of:

[0274] a change in some aspect of the strategy;

[0275] A new security defect is published that affects the database instance; or

[0276] The severity score of the existing security defect is changed to a new value causing the database instance to now be in violation of the policy.

[0277] 33. The computer-implemented method of any of clauses 28-32, wherein the database instance executes in an internal environment of an organization distinct from the provider network.

[0278] 34. The computer-implemented method of any of clauses 28-33, wherein the database instance executes in a self-managed manner via a hardware virtualization service of the provider network.

[0279] 35. A system, comprising:

[0280] first one or more electronic devices for hosting a database instance in a multi-tenant provider network; and

[0281] second one or more electronic devices, the second one or more electronic devices being configured to implement a database customization service in the multi-tenant provider network, the database customization service comprising instructions that, when executed, cause the database customization service to:

[0282] obtaining a first user-specified policy to control creation of a custom database engine version within the provider network;

[0283] receiving a request to create a custom database engine version, wherein the request is initiated on behalf of a second user of the provider network;

[0284] determining that the user-specified policy has been violated; and

[0285] The request to create the custom database engine version is denied or the first user or the second user is notified of the violation of the user-specified policy.

[0286] 36. The system of clause 35, wherein the policy indicates that any database instance created based on the custom database engine version must have a feature enabled or must have the feature disabled.

[0287] 37. The system of any of clauses 35-36, wherein the policy directs any database instance created based on the custom database engine version to utilize an operating system or database engine that satisfies conditions of the policy.

[0288] 38. The system of clause 37, wherein the condition specifies that the operating system or the database engine:

[0289] Issued by a supplier from a group of approved suppliers;

[0290] It is open source;

[0291] Possess one of a group of approved licenses;

[0292] Patched with the specified patch; or

[0293] There are no known security defects of a specific type or severity.

[0294] 39. The system of any one of clauses 35-39, wherein the database customization service further:

[0295] receiving a second request to create the custom database engine version, wherein the second request identifies an updated configuration;

[0296] Creating the custom database engine version according to the updated configuration;

[0297] determining that a database instance launched based on use of the custom database engine version now violates the policy; and

[0298] In response, an action is performed.

[0299] 40. The system of clause 39, wherein the action comprises one of:

[0300] identifying an upgrade of the database instance that will bring the database instance into compliance with the policy again and scheduling the upgrade;

[0301] placing the database instance in network isolation, wherein while in the network isolation, at least some network connections of the database instance are eliminated or restricted; or

[0302] Terminate the database instance.

[0303] 41. A computer-implemented method, the method comprising:

[0304] receiving a first request to create a custom database engine version, the request identifying a configuration associated with a database engine or an operating system, wherein the configuration includes at least an identifier of a storage location having one or more database installation files;

[0305] automatically generating a recommended modification to the configuration based at least in part on the analysis of the configuration;

[0306] causing the recommended modification to be presented via a user interface;

[0307] receiving a second request to create the custom database engine version, the second request identifying an updated configuration including the recommended modification;

[0308] generating the custom database engine version according to the updated configuration;

[0309] receiving a request to start a database, the request including an identifier of the custom database engine version; and

[0310] A database instance is started based on the database engine version.

[0311] 42. A computer-implemented method as described in clause 41, wherein the recommended modification includes applying a first software patch, and wherein the method further includes identifying the first software patch based at least in part on an analysis of a first set of one or more software patches specified by the configuration as needing to be installed to generate the customized database engine version.

[0312] 43. The computer-implemented method of any of clauses 41-42, wherein automatically generating the recommended modification to the configuration further comprises:

[0313] determining that the first configuration does not meet the compliance criteria,

[0314] If applied to the first configuration, the recommended modification will make the custom database engine version or a database instance started based on the use of the custom database engine version meet the compliance standard.

[0315] 44. A computer-implemented method, the method comprising:

[0316] receiving a request to create a custom database engine version, the request identifying a first configuration;

[0317] automatically generating a recommended modification to the first configuration based at least in part on the analysis of the first configuration;

[0318] causing the recommended modification to be presented via a user interface; and

[0319] The customized database engine version is generated according to a second configuration including the recommended modifications, wherein the second configuration is different from the first configuration.

[0320] 45. The computer-implemented method of clause 44, wherein the generating of the recommended modification is further based on an identifier of an application to be used with a database instance launched based on the customized database engine version.

[0321] 46. ​​The computer-implemented method of clause 45, further comprising:

[0322] Obtaining the identifier of the application from within the request; or

[0323] The identifier of the application is inferred based on analysis of a database installation file associated with the request.

[0324] 47. The computer-implemented method of any of clauses 44-46, wherein the recommended modification comprises at least one of:

[0325] Recommended operating system type, version, or configuration; or

[0326] Recommended database engine type, version, or configuration.

[0327] 48. The computer-implemented method of any of clauses 44-46, wherein the recommended modification comprises at least one of:

[0328] Recommended software updates or patches to be applied to the operating system or database engine; or

[0329] Recommended features or extensions to enable or disable for the operating system or the database engine.

[0330] 49. The computer-implemented method of any of clauses 44-46, wherein the recommended modification comprises applying a software patch, adding an additional installation file, or enabling a database engine extension or feature.

[0331] 50. The computer-implemented method of clause 49, wherein automatically generating the recommended modification comprises:

[0332] identifying a third configuration based on use of the first configuration; and

[0333] The first configuration is compared to the third configuration.

[0334] 51. The computer-implemented method of clause 49, wherein automatically generating the recommended modification comprises:

[0335] identifying a feature or extension associated with the first configuration; and

[0336] determining that the first configuration does not specify a software patch associated with the feature or extension,

[0337] The recommended modification includes the addition of the software patch.

[0338] 52. The computer-implemented method of any of clauses 44-49, wherein automatically generating the recommended modification to the first configuration further comprises:

[0339] determining that the first configuration does not meet the compliance standard,

[0340] If applied to the first configuration, the recommended modification will make the custom database engine version or a database instance started based on the use of the custom database engine version meet the compliance standard.

[0341] 53. The computer-implemented method of any of clauses 44-46, wherein automatically generating the recommended modification to the configuration based at least in part on an analysis of the configuration comprises:

[0342] comparing the first configuration to a third configuration of a second custom database engine version; and

[0343] determining that a set of patches or vulnerability fixes specified by the first configuration does not include at least one patch or vulnerability fix of the third configuration,

[0344] Wherein the recommended modification comprises adding the at least one patch or vulnerability fix to the first configuration.

[0345] 54. A system, comprising:

[0346] a first one or more electronic devices configured to implement a storage service in a multi-tenant provider network, the storage service configured to receive and store one or more database installation files at a storage location associated with a user account; and

[0347] second one or more electronic devices, the second one or more electronic devices being configured to implement a database customization service in the multi-tenant provider network, the database customization service comprising instructions that, when executed, cause the database customization service to:

[0348] receiving a request to create a custom database engine version, the request identifying a first configuration, the request further identifying the storage location or the one or more database installation files;

[0349] automatically generating a recommended modification to the first configuration based at least in part on the analysis of the first configuration;

[0350] causing the recommended modification to be presented via a user interface; and

[0351] The customized database engine version is generated according to a second configuration including the recommended modifications, wherein the second configuration is different from the first configuration.

[0352] 55. The system of clause 54, wherein the generating of the recommended modifications is further based on an identifier of an application to be used with a database instance launched based on the custom database engine version.

[0353] 56. The system of clause 55, wherein the database customization service further comprises instructions that, when executed, cause the database customization service to:

[0354] Obtaining the identifier of the application from within the request; or

[0355] The identifier of the application is inferred based on analysis of a database installation file associated with the request.

[0356] 57. The system of any of clauses 54-56, wherein the recommended modification comprises at least one of:

[0357] Recommended operating system type, version, or configuration; or

[0358] Recommended database engine type, version, or configuration.

[0359] 58. The system of any of clauses 54-56, wherein the recommended modification comprises at least one of:

[0360] Recommended software updates or patches to be applied to the operating system or database engine; or

[0361] Recommended features or extensions to enable for the operating system or the database engine.

[0362] 59. The system of any of clauses 54-58, wherein to automatically generate the recommended modifications, the database customization service:

[0363] identifying a third configuration based on use of the first configuration; and

[0364] The first configuration is compared to the third configuration.

[0365] 60. The system of any of clauses 54-59, wherein to automatically generate the recommended modifications to the configuration, the database customization service is to:

[0366] determining that the first configuration does not meet the compliance standard,

[0367] If applied to the first configuration, the recommended modification will make the custom database engine version or a database instance started based on the use of the custom database engine version meet the compliance standard.

[0368] The specification and drawings are accordingly to be regarded in an illustrative rather than a restrictive sense.It will, however, be evident that various modifications and changes may be made thereto without departing from the broader spirit and scope of the disclosure as set forth in the claims.

Claims

1. A computer-implemented method, the method comprising: executing database customization service code on a computing device, the computing device comprising a processor for implementing a database customization service in a provider network; receiving, by the database customization service, input of database customization service code that executes a policy specified by a first user to control creation of a customized database engine version within the provider network by other users belonging to the same organization as the first user, and further controlling ongoing execution of database instances launched in the provider network based on the customized database engine version; receiving, by the database customization service, input of database customization service code that executes a request to create a customized database engine version, wherein the request is initiated by a second user on behalf of the organization and identifies a configuration associated with a database engine; Obtaining an output of determining whether the configuration violates the policy by executing a database customized service code based on an evaluation of the policy; as well as The request to create the customized database engine version is rejected by the database customization service or the first user or the second user is notified that the configuration violates the policy.

2. The computer-implemented method of claim 1, wherein the policy indicates that any database instance created based on the custom database engine version must utilize an operating system or database engine that satisfies the conditions of the policy.

3. The computer-implemented method of claim 2, wherein the condition specifies the operating system or the database engine: is a version from a set of approved versions; Causes a feature to be enabled or disabled; Issued by a supplier from a group of approved suppliers; It is open source; Possess one of a group of approved licenses; Patched with specified patches or bug fixes; There are no known security defects of a particular type or severity; not lacking any updates or patches of a particular type that have become available within the threshold amount of time; or Meet compliance program requirements.

4. A computer-implemented method, the method comprising: executing database customization service code on a computing device, the computing device comprising a processor for implementing a database customization service in a provider network; receiving, by the database customization service, input of database customization service code that executes a policy specified by the first user to control creation of a customized database engine version within the provider network; receiving, by the database customization service, input of database customization service code for executing a request to create a customized database engine version, wherein the request is initiated on behalf of a second user; Obtaining an output of a determination that the customized database engine version violates the policy by executing a database customization service code; as well as The request to create the customized database engine version is rejected by the database customization service, or the first user or the second user is notified that the customized database engine version violates the policy.

5. The computer-implemented method of claim 4, wherein the policy indicates that any database instance created based on the customized database engine version must have a feature enabled or must have the feature disabled.

6. The computer-implemented method of claim 4, wherein the policy indicates that any database instance created based on the custom database engine version must utilize an operating system or database engine that satisfies the conditions of the policy.

7. The computer-implemented method of claim 6, wherein the condition specifies the operating system or the database engine: is a version from a set of approved versions; Causes a feature to be enabled or disabled; Issued by a supplier from a group of approved suppliers; Possess one of a group of approved licenses; Patched with the specified patch; There are no known security defects of a particular type or severity; not lacking any updates or patches of a particular type that have become available within the threshold amount of time; or Meet compliance program requirements.

8. The computer-implemented method of claim 4, wherein the policy further controls continued execution of a database instance launched using the custom database engine version, and wherein the method further comprises: receiving a second request to create the custom database engine version, wherein the second request identifies an updated configuration; Creating the custom database engine version according to the updated configuration; determining that a database instance launched based on use of the custom database engine version now violates the policy; as well as In response to determining that the customized database engine version now violates the policy, an action is performed.

9. The computer-implemented method of claim 8, wherein the actions include: identifying an upgrade to the database instance that will bring the database instance into compliance with the policy again; as well as An upgrade of the database instance is scheduled based on the identified upgrade or a notification is provided indicating the availability of the upgrade.

10. The computer-implemented method of claim 8, wherein the actions include: placing the database instance in network isolation, wherein while in the network isolation, at least some network connections of the database instance are eliminated or limited; or Terminate the database instance.

11. The computer-implemented method of claim 8, wherein the policy indicates that any executing database instance launched based on use of the custom database engine version is to be updated or patched within a threshold amount of time after a particular type of update or patch is released.

12. The computer-implemented method of claim 8, wherein the database instance violates the policy due to one of: a change in some aspect of the strategy; A new security defect is published that affects the database instance; or The severity score of the existing security defect is changed to a new value causing the database instance to now be in violation of the policy.

13. The computer-implemented method of claim 8, wherein the database instance executes in an internal environment of an organization distinct from the provider network.

14. The computer-implemented method of claim 8, wherein the database instance executes in a self-managed manner via a hardware virtualization service of the provider network.

15. A system, comprising: a first one or more electronic devices for hosting a database instance in a multi-tenant provider network; as well as second one or more electronic devices, the second one or more electronic devices are used to implement a database customization service in the multi-tenant provider network, the database customization service uses a processor to execute a database customization service code so that the database customization service: receiving input to a database customization service code that executes a policy specified by a first user to control creation of a customized database engine version within the multi-tenant provider network; receiving input to a database customization service code that executes a request to create a customized database engine version, wherein the request is initiated on behalf of a second user of the multi-tenant provider network; Obtaining an output of a determination that the customized database engine version violates the policy by executing a database customization service code; as well as The request to create the custom database engine version is denied or the first user or the second user is notified that the custom database engine version violates the policy.

16. The system of claim 15, wherein the policy indicates that any database instance created based on the customized database engine version must have a certain feature enabled or must have the feature disabled.

17. The system of claim 15, wherein the policy instructs any database instance created based on the customized database engine version to utilize an operating system or a database engine that satisfies a condition of the policy.

18. The system of claim 17, wherein the condition specifies the operating system or the database engine: Issued by a supplier from a group of approved suppliers; It is open source; Possess one of a group of approved licenses; Patched with the specified patch; or There are no known security defects of a specific type or severity.

19. The system of claim 15, wherein the database customization service is further used for: receiving a second request to create the custom database engine version, wherein the second request identifies an updated configuration; Creating the custom database engine version according to the updated configuration; determining that a database instance launched based on use of the custom database engine version now violates the policy; and In response, an action is performed.

20. The system of claim 19, wherein the action comprises one of: identifying an upgrade of the database instance that will bring the database instance into compliance with the policy again and scheduling the upgrade; placing the database instance in network isolation, wherein while in the network isolation, at least some network connectivity of the database instance is eliminated or limited; or Terminate the database instance.

Images