@cloud-ru/uikit-product-calculator 1.4.5 → 1.5.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +12 -0
- package/dist/cjs/config/platforms/evolution/catalog.js +12 -0
- package/dist/cjs/config/platforms/evolution/constants.d.ts +2 -0
- package/dist/cjs/config/platforms/evolution/constants.js +2 -0
- package/dist/cjs/config/platforms/evolution/product-config/EvolutionManagedClickHouse.d.ts +2 -0
- package/dist/cjs/config/platforms/evolution/product-config/EvolutionManagedClickHouse.js +178 -0
- package/dist/cjs/config/platforms/evolution/product-config/EvolutionManagedKafka.d.ts +2 -0
- package/dist/cjs/config/platforms/evolution/product-config/EvolutionManagedKafka.js +72 -0
- package/dist/cjs/config/platforms/evolution/product-config/index.d.ts +2 -0
- package/dist/cjs/config/platforms/evolution/product-config/index.js +2 -0
- package/dist/cjs/config/platforms/evolution/products.js +20 -0
- package/dist/cjs/constants.d.ts +2 -0
- package/dist/cjs/constants.js +2 -0
- package/dist/esm/config/platforms/evolution/catalog.js +12 -0
- package/dist/esm/config/platforms/evolution/constants.d.ts +2 -0
- package/dist/esm/config/platforms/evolution/constants.js +2 -0
- package/dist/esm/config/platforms/evolution/product-config/EvolutionManagedClickHouse.d.ts +2 -0
- package/dist/esm/config/platforms/evolution/product-config/EvolutionManagedClickHouse.js +175 -0
- package/dist/esm/config/platforms/evolution/product-config/EvolutionManagedKafka.d.ts +2 -0
- package/dist/esm/config/platforms/evolution/product-config/EvolutionManagedKafka.js +69 -0
- package/dist/esm/config/platforms/evolution/product-config/index.d.ts +2 -0
- package/dist/esm/config/platforms/evolution/product-config/index.js +2 -0
- package/dist/esm/config/platforms/evolution/products.js +22 -2
- package/dist/esm/constants.d.ts +2 -0
- package/dist/esm/constants.js +2 -0
- package/package.json +2 -2
- package/src/config/platforms/evolution/catalog.tsx +12 -0
- package/src/config/platforms/evolution/constants.ts +2 -0
- package/src/config/platforms/evolution/product-config/EvolutionManagedClickHouse.ts +194 -0
- package/src/config/platforms/evolution/product-config/EvolutionManagedKafka.ts +75 -0
- package/src/config/platforms/evolution/product-config/index.ts +2 -0
- package/src/config/platforms/evolution/products.ts +24 -0
- package/src/constants.ts +2 -0
package/CHANGELOG.md
CHANGED
|
@@ -3,6 +3,18 @@
|
|
|
3
3
|
All notable changes to this project will be documented in this file.
|
|
4
4
|
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
|
|
5
5
|
|
|
6
|
+
# 1.5.0 (2026-04-06)
|
|
7
|
+
|
|
8
|
+
|
|
9
|
+
### Features
|
|
10
|
+
|
|
11
|
+
* **SITE-10671:** add new calculator Kafka ([4db2cf4](https://github.com/cloud-ru-tech/uikit-product/commit/4db2cf45738945e9ce761bf129874e4ed72c1936))
|
|
12
|
+
* **SITE-10672:** add new calculator ClickHouse ([9c0a8e8](https://github.com/cloud-ru-tech/uikit-product/commit/9c0a8e8b80e5982a90d1c4e1a4b26f8293db4e6e))
|
|
13
|
+
|
|
14
|
+
|
|
15
|
+
|
|
16
|
+
|
|
17
|
+
|
|
6
18
|
## 1.4.5 (2026-04-03)
|
|
7
19
|
|
|
8
20
|
### Only dependencies have been changed
|
|
@@ -84,6 +84,18 @@ exports.EVOLUTION_CATALOG = {
|
|
|
84
84
|
constants_2.EVOLUTION_PRODUCT.EvolutionManagedBI,
|
|
85
85
|
],
|
|
86
86
|
},
|
|
87
|
+
{
|
|
88
|
+
id: constants_1.CATEGORY.Dataset,
|
|
89
|
+
label: 'Базы данных',
|
|
90
|
+
dataTestId: 'dataset',
|
|
91
|
+
visibleProducts: [constants_2.EVOLUTION_PRODUCT.EvolutionManagedClickHouse],
|
|
92
|
+
},
|
|
93
|
+
{
|
|
94
|
+
id: constants_1.CATEGORY.Brokers,
|
|
95
|
+
label: 'Брокеры сообщений',
|
|
96
|
+
dataTestId: 'brokers',
|
|
97
|
+
visibleProducts: [constants_2.EVOLUTION_PRODUCT.EvolutionManagedKafka],
|
|
98
|
+
},
|
|
87
99
|
{
|
|
88
100
|
id: constants_1.CATEGORY.ML,
|
|
89
101
|
label: 'ML/AI Инструменты',
|
|
@@ -18,7 +18,9 @@ export declare const EVOLUTION_PRODUCT: {
|
|
|
18
18
|
readonly EvolutionManagedTrino: "evolutionManagedTrino";
|
|
19
19
|
readonly EvolutionManagedBI: "evolutionManagedBI";
|
|
20
20
|
readonly EvolutionManagedRedis: "evolutionManagedRedis";
|
|
21
|
+
readonly EvolutionManagedClickHouse: "evolutionManagedClickhouse";
|
|
21
22
|
readonly EvolutionManagedSpark: "evolutionManagedSpark";
|
|
23
|
+
readonly EvolutionManagedKafka: "evolutionManagedKafka";
|
|
22
24
|
readonly EvolutionLoadBalancer: "evolutionLoadBalancer";
|
|
23
25
|
readonly EvolutionNotebooks: "evolutionNotebooks";
|
|
24
26
|
};
|
|
@@ -21,7 +21,9 @@ exports.EVOLUTION_PRODUCT = {
|
|
|
21
21
|
EvolutionManagedTrino: 'evolutionManagedTrino',
|
|
22
22
|
EvolutionManagedBI: 'evolutionManagedBI',
|
|
23
23
|
EvolutionManagedRedis: 'evolutionManagedRedis',
|
|
24
|
+
EvolutionManagedClickHouse: 'evolutionManagedClickhouse',
|
|
24
25
|
EvolutionManagedSpark: 'evolutionManagedSpark',
|
|
26
|
+
EvolutionManagedKafka: 'evolutionManagedKafka',
|
|
25
27
|
EvolutionLoadBalancer: 'evolutionLoadBalancer',
|
|
26
28
|
EvolutionNotebooks: 'evolutionNotebooks',
|
|
27
29
|
};
|
|
@@ -0,0 +1,178 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.EVOLUTION_MANAGED_CLICKHOUSE_CONFIG = void 0;
|
|
4
|
+
const components_1 = require("../../../../components");
|
|
5
|
+
const utils_1 = require("../../../utils");
|
|
6
|
+
const valueSingleNode = 'Single-node';
|
|
7
|
+
const valueSingleShard = 'Single-shard';
|
|
8
|
+
const valueMultiShard = 'Multi-shard';
|
|
9
|
+
const CPU = [4, 8];
|
|
10
|
+
const RAM = [16, 32];
|
|
11
|
+
const cpuToRamMap = {
|
|
12
|
+
'4': [16],
|
|
13
|
+
'8': [32],
|
|
14
|
+
};
|
|
15
|
+
const cpuConfigItems = {
|
|
16
|
+
[valueSingleNode]: (0, utils_1.generateCpuItems)(CPU),
|
|
17
|
+
[valueSingleShard]: (0, utils_1.generateCpuItems)(CPU),
|
|
18
|
+
[valueMultiShard]: (0, utils_1.generateCpuItems)([CPU[0]]),
|
|
19
|
+
};
|
|
20
|
+
const ramConfigItems = {
|
|
21
|
+
[valueSingleNode]: RAM,
|
|
22
|
+
[valueSingleShard]: RAM,
|
|
23
|
+
[valueMultiShard]: [RAM[0]],
|
|
24
|
+
};
|
|
25
|
+
const instanceTypePartCards = [
|
|
26
|
+
{
|
|
27
|
+
value: valueSingleNode,
|
|
28
|
+
label: valueSingleNode,
|
|
29
|
+
description: 'Шард с одной репликой',
|
|
30
|
+
},
|
|
31
|
+
{
|
|
32
|
+
value: valueSingleShard,
|
|
33
|
+
label: valueSingleShard,
|
|
34
|
+
description: 'Шард с репликами',
|
|
35
|
+
},
|
|
36
|
+
{
|
|
37
|
+
value: valueMultiShard,
|
|
38
|
+
label: valueMultiShard,
|
|
39
|
+
description: 'Несколько шардов с репликами',
|
|
40
|
+
},
|
|
41
|
+
];
|
|
42
|
+
const shardQuantityItemsByInstantType = {
|
|
43
|
+
[valueSingleNode]: [1],
|
|
44
|
+
[valueSingleShard]: [1],
|
|
45
|
+
[valueMultiShard]: [3],
|
|
46
|
+
};
|
|
47
|
+
const hostQuantityItemsByInstantType = {
|
|
48
|
+
[valueSingleNode]: [1],
|
|
49
|
+
[valueSingleShard]: [3],
|
|
50
|
+
[valueMultiShard]: [3],
|
|
51
|
+
};
|
|
52
|
+
exports.EVOLUTION_MANAGED_CLICKHOUSE_CONFIG = {
|
|
53
|
+
ui: ['instanceType', ['vCpuCoreCount', 'ramAmount'], ['shardQuantity', 'hostQuantity'], ['systemDisk']],
|
|
54
|
+
controls: {
|
|
55
|
+
instanceType: {
|
|
56
|
+
decoratorProps: {
|
|
57
|
+
label: 'Тип инстанса',
|
|
58
|
+
},
|
|
59
|
+
type: components_1.CONTROL.Carousel,
|
|
60
|
+
accessorKey: 'instanceType',
|
|
61
|
+
defaultValue: instanceTypePartCards[0].value,
|
|
62
|
+
items: instanceTypePartCards,
|
|
63
|
+
onChangeFn: (value, setValue) => {
|
|
64
|
+
if (value === valueMultiShard) {
|
|
65
|
+
setValue([
|
|
66
|
+
['instanceType', value],
|
|
67
|
+
['shardQuantity', '3'],
|
|
68
|
+
['hostQuantity', '3'],
|
|
69
|
+
]);
|
|
70
|
+
}
|
|
71
|
+
else if (value === valueSingleShard) {
|
|
72
|
+
setValue([
|
|
73
|
+
['instanceType', value],
|
|
74
|
+
['shardQuantity', '1'],
|
|
75
|
+
['hostQuantity', '3'],
|
|
76
|
+
]);
|
|
77
|
+
}
|
|
78
|
+
else {
|
|
79
|
+
setValue([
|
|
80
|
+
['instanceType', value],
|
|
81
|
+
['shardQuantity', '1'],
|
|
82
|
+
['hostQuantity', '1'],
|
|
83
|
+
]);
|
|
84
|
+
}
|
|
85
|
+
},
|
|
86
|
+
},
|
|
87
|
+
vCpuCoreCount: {
|
|
88
|
+
type: components_1.CONTROL.Segmented,
|
|
89
|
+
accessorKey: 'vCpuCoreCount',
|
|
90
|
+
watchedControls: { instanceType: 'instanceType' },
|
|
91
|
+
defaultValue: '4',
|
|
92
|
+
items: (0, utils_1.generateCpuItems)(CPU),
|
|
93
|
+
decoratorProps: {
|
|
94
|
+
label: 'Количество ядер vCPU',
|
|
95
|
+
},
|
|
96
|
+
relateFn: ({ instanceType }) => {
|
|
97
|
+
const items = cpuConfigItems[instanceType];
|
|
98
|
+
if ((items === null || items === void 0 ? void 0 : items.length) > 0) {
|
|
99
|
+
return { items };
|
|
100
|
+
}
|
|
101
|
+
},
|
|
102
|
+
},
|
|
103
|
+
ramAmount: {
|
|
104
|
+
type: components_1.CONTROL.Segmented,
|
|
105
|
+
accessorKey: 'ramAmount',
|
|
106
|
+
watchedControls: { instanceType: 'instanceType', vCpuCoreCount: 'vCpuCoreCount' },
|
|
107
|
+
defaultValue: '16',
|
|
108
|
+
items: (0, utils_1.generateRamItems)(RAM),
|
|
109
|
+
decoratorProps: {
|
|
110
|
+
label: 'Количество оперативной памяти (RAM)',
|
|
111
|
+
},
|
|
112
|
+
relateFn: ({ instanceType, vCpuCoreCount }) => {
|
|
113
|
+
const itemsByInstanceType = ramConfigItems[instanceType];
|
|
114
|
+
const itemsByCpu = new Set(cpuToRamMap[vCpuCoreCount]);
|
|
115
|
+
if ((itemsByInstanceType === null || itemsByInstanceType === void 0 ? void 0 : itemsByInstanceType.length) > 0) {
|
|
116
|
+
const resolvedItems = itemsByInstanceType.filter(item => itemsByCpu.has(item));
|
|
117
|
+
return {
|
|
118
|
+
items: (0, utils_1.generateRamItems)(resolvedItems),
|
|
119
|
+
};
|
|
120
|
+
}
|
|
121
|
+
},
|
|
122
|
+
},
|
|
123
|
+
shardQuantity: {
|
|
124
|
+
type: components_1.CONTROL.Segmented,
|
|
125
|
+
decoratorProps: {
|
|
126
|
+
label: 'Количество шардов',
|
|
127
|
+
},
|
|
128
|
+
defaultValue: '1',
|
|
129
|
+
items: (0, utils_1.generateCpuItems)([1]),
|
|
130
|
+
accessorKey: 'shardQuantity',
|
|
131
|
+
watchedControls: { instanceType: 'instanceType' },
|
|
132
|
+
relateFn: ({ instanceType }) => {
|
|
133
|
+
const items = shardQuantityItemsByInstantType[instanceType];
|
|
134
|
+
if ((items === null || items === void 0 ? void 0 : items.length) > 0) {
|
|
135
|
+
return {
|
|
136
|
+
items: (0, utils_1.generateCpuItems)(items),
|
|
137
|
+
};
|
|
138
|
+
}
|
|
139
|
+
},
|
|
140
|
+
},
|
|
141
|
+
hostQuantity: {
|
|
142
|
+
type: components_1.CONTROL.Segmented,
|
|
143
|
+
decoratorProps: {
|
|
144
|
+
label: 'Количество хостов',
|
|
145
|
+
},
|
|
146
|
+
defaultValue: '1',
|
|
147
|
+
items: (0, utils_1.generateCpuItems)([1]),
|
|
148
|
+
accessorKey: 'hostQuantity',
|
|
149
|
+
watchedControls: { instanceType: 'instanceType' },
|
|
150
|
+
relateFn: ({ instanceType }) => {
|
|
151
|
+
const items = hostQuantityItemsByInstantType[instanceType];
|
|
152
|
+
if ((items === null || items === void 0 ? void 0 : items.length) > 0) {
|
|
153
|
+
return {
|
|
154
|
+
items: (0, utils_1.generateCpuItems)(items),
|
|
155
|
+
};
|
|
156
|
+
}
|
|
157
|
+
},
|
|
158
|
+
},
|
|
159
|
+
systemDisk: (0, utils_1.getDisk)({
|
|
160
|
+
space: {
|
|
161
|
+
label: 'Диск',
|
|
162
|
+
accessorKey: 'diskCapacity',
|
|
163
|
+
defaultValue: 40,
|
|
164
|
+
uiProps: {
|
|
165
|
+
min: 40,
|
|
166
|
+
max: 16384,
|
|
167
|
+
},
|
|
168
|
+
},
|
|
169
|
+
specification: {
|
|
170
|
+
accessorKey: 'diskType',
|
|
171
|
+
defaultValue: 'SSD',
|
|
172
|
+
uiProps: {
|
|
173
|
+
disabled: true,
|
|
174
|
+
},
|
|
175
|
+
},
|
|
176
|
+
}),
|
|
177
|
+
},
|
|
178
|
+
};
|
|
@@ -0,0 +1,72 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.EVOLUTION_MANAGED_KAFKA_CONFIG = void 0;
|
|
4
|
+
const components_1 = require("../../../../components");
|
|
5
|
+
const utils_1 = require("../../../utils");
|
|
6
|
+
const CPU = [2, 4, 8];
|
|
7
|
+
const RAM = [4, 8, 16, 32];
|
|
8
|
+
const cpuToRamMap = {
|
|
9
|
+
'2': [4],
|
|
10
|
+
'4': [8, 16],
|
|
11
|
+
'8': [32],
|
|
12
|
+
};
|
|
13
|
+
const brokerQuantity = [1, 3, 5, 7];
|
|
14
|
+
exports.EVOLUTION_MANAGED_KAFKA_CONFIG = {
|
|
15
|
+
ui: [['vCpuCoreCount', 'ramAmount'], ['brokerQuantity'], ['systemDisk']],
|
|
16
|
+
controls: {
|
|
17
|
+
vCpuCoreCount: {
|
|
18
|
+
type: components_1.CONTROL.Segmented,
|
|
19
|
+
accessorKey: 'vCpuCoreCount',
|
|
20
|
+
defaultValue: '2',
|
|
21
|
+
items: (0, utils_1.generateCpuItems)(CPU),
|
|
22
|
+
decoratorProps: {
|
|
23
|
+
label: 'Количество ядер vCPU',
|
|
24
|
+
},
|
|
25
|
+
},
|
|
26
|
+
ramAmount: {
|
|
27
|
+
type: components_1.CONTROL.Segmented,
|
|
28
|
+
accessorKey: 'ramAmount',
|
|
29
|
+
watchedControls: { vCpuCoreCount: 'vCpuCoreCount' },
|
|
30
|
+
defaultValue: '4',
|
|
31
|
+
items: (0, utils_1.generateRamItems)(RAM),
|
|
32
|
+
decoratorProps: {
|
|
33
|
+
label: 'Количество оперативной памяти (RAM)',
|
|
34
|
+
},
|
|
35
|
+
relateFn: ({ vCpuCoreCount }) => {
|
|
36
|
+
const itemsByCpu = cpuToRamMap[vCpuCoreCount];
|
|
37
|
+
if ((itemsByCpu === null || itemsByCpu === void 0 ? void 0 : itemsByCpu.length) > 0) {
|
|
38
|
+
return {
|
|
39
|
+
items: (0, utils_1.generateRamItems)(itemsByCpu),
|
|
40
|
+
};
|
|
41
|
+
}
|
|
42
|
+
},
|
|
43
|
+
},
|
|
44
|
+
brokerQuantity: {
|
|
45
|
+
type: components_1.CONTROL.Segmented,
|
|
46
|
+
decoratorProps: {
|
|
47
|
+
label: 'Количество брокеров',
|
|
48
|
+
},
|
|
49
|
+
defaultValue: '1',
|
|
50
|
+
items: (0, utils_1.generateCpuItems)(brokerQuantity),
|
|
51
|
+
accessorKey: 'brokerQuantity',
|
|
52
|
+
},
|
|
53
|
+
systemDisk: (0, utils_1.getDisk)({
|
|
54
|
+
space: {
|
|
55
|
+
label: 'Диск',
|
|
56
|
+
accessorKey: 'diskCapacity',
|
|
57
|
+
defaultValue: 40,
|
|
58
|
+
uiProps: {
|
|
59
|
+
min: 40,
|
|
60
|
+
max: 16384,
|
|
61
|
+
},
|
|
62
|
+
},
|
|
63
|
+
specification: {
|
|
64
|
+
accessorKey: 'diskType',
|
|
65
|
+
defaultValue: 'SSD',
|
|
66
|
+
uiProps: {
|
|
67
|
+
disabled: true,
|
|
68
|
+
},
|
|
69
|
+
},
|
|
70
|
+
}),
|
|
71
|
+
},
|
|
72
|
+
};
|
|
@@ -19,4 +19,6 @@ export * from './EvolutionDNS';
|
|
|
19
19
|
export * from './EvolutionLoadBalancer';
|
|
20
20
|
export * from './EvolutionManagedBI';
|
|
21
21
|
export * from './EvolutionManagedRedis';
|
|
22
|
+
export * from './EvolutionManagedClickHouse';
|
|
22
23
|
export * from './EvolutionManagedSpark';
|
|
24
|
+
export * from './EvolutionManagedKafka';
|
|
@@ -35,4 +35,6 @@ __exportStar(require("./EvolutionDNS"), exports);
|
|
|
35
35
|
__exportStar(require("./EvolutionLoadBalancer"), exports);
|
|
36
36
|
__exportStar(require("./EvolutionManagedBI"), exports);
|
|
37
37
|
__exportStar(require("./EvolutionManagedRedis"), exports);
|
|
38
|
+
__exportStar(require("./EvolutionManagedClickHouse"), exports);
|
|
38
39
|
__exportStar(require("./EvolutionManagedSpark"), exports);
|
|
40
|
+
__exportStar(require("./EvolutionManagedKafka"), exports);
|
|
@@ -90,6 +90,16 @@ exports.EVOLUTION_PRODUCTS = {
|
|
|
90
90
|
dataTestId: 'EvolutionManagedRedis',
|
|
91
91
|
enableConnectToConsole: true,
|
|
92
92
|
},
|
|
93
|
+
[constants_2.EVOLUTION_PRODUCT.EvolutionManagedClickHouse]: {
|
|
94
|
+
id: constants_2.EVOLUTION_PRODUCT.EvolutionManagedClickHouse,
|
|
95
|
+
platform: constants_1.PLATFORM.Evolution,
|
|
96
|
+
label: 'Evolution Managed ClickHouse',
|
|
97
|
+
caption: 'Управляемая аналитическая СУБД в облаке на базе ClickHouse®',
|
|
98
|
+
formConfig: product_config_1.EVOLUTION_MANAGED_CLICKHOUSE_CONFIG,
|
|
99
|
+
icon: uikit_product_icons_1.ManagedClickHouseSVG,
|
|
100
|
+
dataTestId: 'EvolutionManagedClickhouse',
|
|
101
|
+
enableConnectToConsole: true,
|
|
102
|
+
},
|
|
93
103
|
[constants_2.EVOLUTION_PRODUCT.EvolutionLoadBalancer]: {
|
|
94
104
|
id: constants_2.EVOLUTION_PRODUCT.EvolutionLoadBalancer,
|
|
95
105
|
platform: constants_1.PLATFORM.Evolution,
|
|
@@ -100,6 +110,16 @@ exports.EVOLUTION_PRODUCTS = {
|
|
|
100
110
|
dataTestId: 'EvolutionLoadBalancer',
|
|
101
111
|
enableConnectToConsole: true,
|
|
102
112
|
},
|
|
113
|
+
[constants_2.EVOLUTION_PRODUCT.EvolutionManagedKafka]: {
|
|
114
|
+
id: constants_2.EVOLUTION_PRODUCT.EvolutionManagedKafka,
|
|
115
|
+
platform: constants_1.PLATFORM.Evolution,
|
|
116
|
+
label: 'Evolution Managed Kafka',
|
|
117
|
+
caption: 'Готовый кластер Apache Kafka® — сервис для потоковой обработки данных в реальном времени',
|
|
118
|
+
formConfig: product_config_1.EVOLUTION_MANAGED_KAFKA_CONFIG,
|
|
119
|
+
icon: uikit_product_icons_1.ManagedKafkaSVG,
|
|
120
|
+
dataTestId: 'EvolutionManagedKafka',
|
|
121
|
+
enableConnectToConsole: true,
|
|
122
|
+
},
|
|
103
123
|
[constants_2.EVOLUTION_PRODUCT.EvolutionStorageS3]: {
|
|
104
124
|
id: constants_2.EVOLUTION_PRODUCT.EvolutionStorageS3,
|
|
105
125
|
platform: constants_1.PLATFORM.Evolution,
|
package/dist/cjs/constants.d.ts
CHANGED
|
@@ -15,6 +15,8 @@ export declare const CATEGORY: {
|
|
|
15
15
|
readonly Containerization: "containerization";
|
|
16
16
|
readonly Storage: "storage";
|
|
17
17
|
readonly Database: "database";
|
|
18
|
+
readonly Dataset: "dataset";
|
|
19
|
+
readonly Brokers: "brokers";
|
|
18
20
|
readonly Development: "development";
|
|
19
21
|
readonly Analytic: "analytic";
|
|
20
22
|
readonly ML: "ml-ai-tools";
|
package/dist/cjs/constants.js
CHANGED
|
@@ -81,6 +81,18 @@ export const EVOLUTION_CATALOG = {
|
|
|
81
81
|
EVOLUTION_PRODUCT.EvolutionManagedBI,
|
|
82
82
|
],
|
|
83
83
|
},
|
|
84
|
+
{
|
|
85
|
+
id: CATEGORY.Dataset,
|
|
86
|
+
label: 'Базы данных',
|
|
87
|
+
dataTestId: 'dataset',
|
|
88
|
+
visibleProducts: [EVOLUTION_PRODUCT.EvolutionManagedClickHouse],
|
|
89
|
+
},
|
|
90
|
+
{
|
|
91
|
+
id: CATEGORY.Brokers,
|
|
92
|
+
label: 'Брокеры сообщений',
|
|
93
|
+
dataTestId: 'brokers',
|
|
94
|
+
visibleProducts: [EVOLUTION_PRODUCT.EvolutionManagedKafka],
|
|
95
|
+
},
|
|
84
96
|
{
|
|
85
97
|
id: CATEGORY.ML,
|
|
86
98
|
label: 'ML/AI Инструменты',
|
|
@@ -18,7 +18,9 @@ export declare const EVOLUTION_PRODUCT: {
|
|
|
18
18
|
readonly EvolutionManagedTrino: "evolutionManagedTrino";
|
|
19
19
|
readonly EvolutionManagedBI: "evolutionManagedBI";
|
|
20
20
|
readonly EvolutionManagedRedis: "evolutionManagedRedis";
|
|
21
|
+
readonly EvolutionManagedClickHouse: "evolutionManagedClickhouse";
|
|
21
22
|
readonly EvolutionManagedSpark: "evolutionManagedSpark";
|
|
23
|
+
readonly EvolutionManagedKafka: "evolutionManagedKafka";
|
|
22
24
|
readonly EvolutionLoadBalancer: "evolutionLoadBalancer";
|
|
23
25
|
readonly EvolutionNotebooks: "evolutionNotebooks";
|
|
24
26
|
};
|
|
@@ -18,7 +18,9 @@ export const EVOLUTION_PRODUCT = {
|
|
|
18
18
|
EvolutionManagedTrino: 'evolutionManagedTrino',
|
|
19
19
|
EvolutionManagedBI: 'evolutionManagedBI',
|
|
20
20
|
EvolutionManagedRedis: 'evolutionManagedRedis',
|
|
21
|
+
EvolutionManagedClickHouse: 'evolutionManagedClickhouse',
|
|
21
22
|
EvolutionManagedSpark: 'evolutionManagedSpark',
|
|
23
|
+
EvolutionManagedKafka: 'evolutionManagedKafka',
|
|
22
24
|
EvolutionLoadBalancer: 'evolutionLoadBalancer',
|
|
23
25
|
EvolutionNotebooks: 'evolutionNotebooks',
|
|
24
26
|
};
|
|
@@ -0,0 +1,175 @@
|
|
|
1
|
+
import { CONTROL } from '../../../../components';
|
|
2
|
+
import { generateCpuItems, generateRamItems, getDisk } from '../../../utils';
|
|
3
|
+
const valueSingleNode = 'Single-node';
|
|
4
|
+
const valueSingleShard = 'Single-shard';
|
|
5
|
+
const valueMultiShard = 'Multi-shard';
|
|
6
|
+
const CPU = [4, 8];
|
|
7
|
+
const RAM = [16, 32];
|
|
8
|
+
const cpuToRamMap = {
|
|
9
|
+
'4': [16],
|
|
10
|
+
'8': [32],
|
|
11
|
+
};
|
|
12
|
+
const cpuConfigItems = {
|
|
13
|
+
[valueSingleNode]: generateCpuItems(CPU),
|
|
14
|
+
[valueSingleShard]: generateCpuItems(CPU),
|
|
15
|
+
[valueMultiShard]: generateCpuItems([CPU[0]]),
|
|
16
|
+
};
|
|
17
|
+
const ramConfigItems = {
|
|
18
|
+
[valueSingleNode]: RAM,
|
|
19
|
+
[valueSingleShard]: RAM,
|
|
20
|
+
[valueMultiShard]: [RAM[0]],
|
|
21
|
+
};
|
|
22
|
+
const instanceTypePartCards = [
|
|
23
|
+
{
|
|
24
|
+
value: valueSingleNode,
|
|
25
|
+
label: valueSingleNode,
|
|
26
|
+
description: 'Шард с одной репликой',
|
|
27
|
+
},
|
|
28
|
+
{
|
|
29
|
+
value: valueSingleShard,
|
|
30
|
+
label: valueSingleShard,
|
|
31
|
+
description: 'Шард с репликами',
|
|
32
|
+
},
|
|
33
|
+
{
|
|
34
|
+
value: valueMultiShard,
|
|
35
|
+
label: valueMultiShard,
|
|
36
|
+
description: 'Несколько шардов с репликами',
|
|
37
|
+
},
|
|
38
|
+
];
|
|
39
|
+
const shardQuantityItemsByInstantType = {
|
|
40
|
+
[valueSingleNode]: [1],
|
|
41
|
+
[valueSingleShard]: [1],
|
|
42
|
+
[valueMultiShard]: [3],
|
|
43
|
+
};
|
|
44
|
+
const hostQuantityItemsByInstantType = {
|
|
45
|
+
[valueSingleNode]: [1],
|
|
46
|
+
[valueSingleShard]: [3],
|
|
47
|
+
[valueMultiShard]: [3],
|
|
48
|
+
};
|
|
49
|
+
export const EVOLUTION_MANAGED_CLICKHOUSE_CONFIG = {
|
|
50
|
+
ui: ['instanceType', ['vCpuCoreCount', 'ramAmount'], ['shardQuantity', 'hostQuantity'], ['systemDisk']],
|
|
51
|
+
controls: {
|
|
52
|
+
instanceType: {
|
|
53
|
+
decoratorProps: {
|
|
54
|
+
label: 'Тип инстанса',
|
|
55
|
+
},
|
|
56
|
+
type: CONTROL.Carousel,
|
|
57
|
+
accessorKey: 'instanceType',
|
|
58
|
+
defaultValue: instanceTypePartCards[0].value,
|
|
59
|
+
items: instanceTypePartCards,
|
|
60
|
+
onChangeFn: (value, setValue) => {
|
|
61
|
+
if (value === valueMultiShard) {
|
|
62
|
+
setValue([
|
|
63
|
+
['instanceType', value],
|
|
64
|
+
['shardQuantity', '3'],
|
|
65
|
+
['hostQuantity', '3'],
|
|
66
|
+
]);
|
|
67
|
+
}
|
|
68
|
+
else if (value === valueSingleShard) {
|
|
69
|
+
setValue([
|
|
70
|
+
['instanceType', value],
|
|
71
|
+
['shardQuantity', '1'],
|
|
72
|
+
['hostQuantity', '3'],
|
|
73
|
+
]);
|
|
74
|
+
}
|
|
75
|
+
else {
|
|
76
|
+
setValue([
|
|
77
|
+
['instanceType', value],
|
|
78
|
+
['shardQuantity', '1'],
|
|
79
|
+
['hostQuantity', '1'],
|
|
80
|
+
]);
|
|
81
|
+
}
|
|
82
|
+
},
|
|
83
|
+
},
|
|
84
|
+
vCpuCoreCount: {
|
|
85
|
+
type: CONTROL.Segmented,
|
|
86
|
+
accessorKey: 'vCpuCoreCount',
|
|
87
|
+
watchedControls: { instanceType: 'instanceType' },
|
|
88
|
+
defaultValue: '4',
|
|
89
|
+
items: generateCpuItems(CPU),
|
|
90
|
+
decoratorProps: {
|
|
91
|
+
label: 'Количество ядер vCPU',
|
|
92
|
+
},
|
|
93
|
+
relateFn: ({ instanceType }) => {
|
|
94
|
+
const items = cpuConfigItems[instanceType];
|
|
95
|
+
if ((items === null || items === void 0 ? void 0 : items.length) > 0) {
|
|
96
|
+
return { items };
|
|
97
|
+
}
|
|
98
|
+
},
|
|
99
|
+
},
|
|
100
|
+
ramAmount: {
|
|
101
|
+
type: CONTROL.Segmented,
|
|
102
|
+
accessorKey: 'ramAmount',
|
|
103
|
+
watchedControls: { instanceType: 'instanceType', vCpuCoreCount: 'vCpuCoreCount' },
|
|
104
|
+
defaultValue: '16',
|
|
105
|
+
items: generateRamItems(RAM),
|
|
106
|
+
decoratorProps: {
|
|
107
|
+
label: 'Количество оперативной памяти (RAM)',
|
|
108
|
+
},
|
|
109
|
+
relateFn: ({ instanceType, vCpuCoreCount }) => {
|
|
110
|
+
const itemsByInstanceType = ramConfigItems[instanceType];
|
|
111
|
+
const itemsByCpu = new Set(cpuToRamMap[vCpuCoreCount]);
|
|
112
|
+
if ((itemsByInstanceType === null || itemsByInstanceType === void 0 ? void 0 : itemsByInstanceType.length) > 0) {
|
|
113
|
+
const resolvedItems = itemsByInstanceType.filter(item => itemsByCpu.has(item));
|
|
114
|
+
return {
|
|
115
|
+
items: generateRamItems(resolvedItems),
|
|
116
|
+
};
|
|
117
|
+
}
|
|
118
|
+
},
|
|
119
|
+
},
|
|
120
|
+
shardQuantity: {
|
|
121
|
+
type: CONTROL.Segmented,
|
|
122
|
+
decoratorProps: {
|
|
123
|
+
label: 'Количество шардов',
|
|
124
|
+
},
|
|
125
|
+
defaultValue: '1',
|
|
126
|
+
items: generateCpuItems([1]),
|
|
127
|
+
accessorKey: 'shardQuantity',
|
|
128
|
+
watchedControls: { instanceType: 'instanceType' },
|
|
129
|
+
relateFn: ({ instanceType }) => {
|
|
130
|
+
const items = shardQuantityItemsByInstantType[instanceType];
|
|
131
|
+
if ((items === null || items === void 0 ? void 0 : items.length) > 0) {
|
|
132
|
+
return {
|
|
133
|
+
items: generateCpuItems(items),
|
|
134
|
+
};
|
|
135
|
+
}
|
|
136
|
+
},
|
|
137
|
+
},
|
|
138
|
+
hostQuantity: {
|
|
139
|
+
type: CONTROL.Segmented,
|
|
140
|
+
decoratorProps: {
|
|
141
|
+
label: 'Количество хостов',
|
|
142
|
+
},
|
|
143
|
+
defaultValue: '1',
|
|
144
|
+
items: generateCpuItems([1]),
|
|
145
|
+
accessorKey: 'hostQuantity',
|
|
146
|
+
watchedControls: { instanceType: 'instanceType' },
|
|
147
|
+
relateFn: ({ instanceType }) => {
|
|
148
|
+
const items = hostQuantityItemsByInstantType[instanceType];
|
|
149
|
+
if ((items === null || items === void 0 ? void 0 : items.length) > 0) {
|
|
150
|
+
return {
|
|
151
|
+
items: generateCpuItems(items),
|
|
152
|
+
};
|
|
153
|
+
}
|
|
154
|
+
},
|
|
155
|
+
},
|
|
156
|
+
systemDisk: getDisk({
|
|
157
|
+
space: {
|
|
158
|
+
label: 'Диск',
|
|
159
|
+
accessorKey: 'diskCapacity',
|
|
160
|
+
defaultValue: 40,
|
|
161
|
+
uiProps: {
|
|
162
|
+
min: 40,
|
|
163
|
+
max: 16384,
|
|
164
|
+
},
|
|
165
|
+
},
|
|
166
|
+
specification: {
|
|
167
|
+
accessorKey: 'diskType',
|
|
168
|
+
defaultValue: 'SSD',
|
|
169
|
+
uiProps: {
|
|
170
|
+
disabled: true,
|
|
171
|
+
},
|
|
172
|
+
},
|
|
173
|
+
}),
|
|
174
|
+
},
|
|
175
|
+
};
|
|
@@ -0,0 +1,69 @@
|
|
|
1
|
+
import { CONTROL } from '../../../../components';
|
|
2
|
+
import { generateCpuItems, generateRamItems, getDisk } from '../../../utils';
|
|
3
|
+
const CPU = [2, 4, 8];
|
|
4
|
+
const RAM = [4, 8, 16, 32];
|
|
5
|
+
const cpuToRamMap = {
|
|
6
|
+
'2': [4],
|
|
7
|
+
'4': [8, 16],
|
|
8
|
+
'8': [32],
|
|
9
|
+
};
|
|
10
|
+
const brokerQuantity = [1, 3, 5, 7];
|
|
11
|
+
export const EVOLUTION_MANAGED_KAFKA_CONFIG = {
|
|
12
|
+
ui: [['vCpuCoreCount', 'ramAmount'], ['brokerQuantity'], ['systemDisk']],
|
|
13
|
+
controls: {
|
|
14
|
+
vCpuCoreCount: {
|
|
15
|
+
type: CONTROL.Segmented,
|
|
16
|
+
accessorKey: 'vCpuCoreCount',
|
|
17
|
+
defaultValue: '2',
|
|
18
|
+
items: generateCpuItems(CPU),
|
|
19
|
+
decoratorProps: {
|
|
20
|
+
label: 'Количество ядер vCPU',
|
|
21
|
+
},
|
|
22
|
+
},
|
|
23
|
+
ramAmount: {
|
|
24
|
+
type: CONTROL.Segmented,
|
|
25
|
+
accessorKey: 'ramAmount',
|
|
26
|
+
watchedControls: { vCpuCoreCount: 'vCpuCoreCount' },
|
|
27
|
+
defaultValue: '4',
|
|
28
|
+
items: generateRamItems(RAM),
|
|
29
|
+
decoratorProps: {
|
|
30
|
+
label: 'Количество оперативной памяти (RAM)',
|
|
31
|
+
},
|
|
32
|
+
relateFn: ({ vCpuCoreCount }) => {
|
|
33
|
+
const itemsByCpu = cpuToRamMap[vCpuCoreCount];
|
|
34
|
+
if ((itemsByCpu === null || itemsByCpu === void 0 ? void 0 : itemsByCpu.length) > 0) {
|
|
35
|
+
return {
|
|
36
|
+
items: generateRamItems(itemsByCpu),
|
|
37
|
+
};
|
|
38
|
+
}
|
|
39
|
+
},
|
|
40
|
+
},
|
|
41
|
+
brokerQuantity: {
|
|
42
|
+
type: CONTROL.Segmented,
|
|
43
|
+
decoratorProps: {
|
|
44
|
+
label: 'Количество брокеров',
|
|
45
|
+
},
|
|
46
|
+
defaultValue: '1',
|
|
47
|
+
items: generateCpuItems(brokerQuantity),
|
|
48
|
+
accessorKey: 'brokerQuantity',
|
|
49
|
+
},
|
|
50
|
+
systemDisk: getDisk({
|
|
51
|
+
space: {
|
|
52
|
+
label: 'Диск',
|
|
53
|
+
accessorKey: 'diskCapacity',
|
|
54
|
+
defaultValue: 40,
|
|
55
|
+
uiProps: {
|
|
56
|
+
min: 40,
|
|
57
|
+
max: 16384,
|
|
58
|
+
},
|
|
59
|
+
},
|
|
60
|
+
specification: {
|
|
61
|
+
accessorKey: 'diskType',
|
|
62
|
+
defaultValue: 'SSD',
|
|
63
|
+
uiProps: {
|
|
64
|
+
disabled: true,
|
|
65
|
+
},
|
|
66
|
+
},
|
|
67
|
+
}),
|
|
68
|
+
},
|
|
69
|
+
};
|
|
@@ -19,4 +19,6 @@ export * from './EvolutionDNS';
|
|
|
19
19
|
export * from './EvolutionLoadBalancer';
|
|
20
20
|
export * from './EvolutionManagedBI';
|
|
21
21
|
export * from './EvolutionManagedRedis';
|
|
22
|
+
export * from './EvolutionManagedClickHouse';
|
|
22
23
|
export * from './EvolutionManagedSpark';
|
|
24
|
+
export * from './EvolutionManagedKafka';
|
|
@@ -19,4 +19,6 @@ export * from './EvolutionDNS';
|
|
|
19
19
|
export * from './EvolutionLoadBalancer';
|
|
20
20
|
export * from './EvolutionManagedBI';
|
|
21
21
|
export * from './EvolutionManagedRedis';
|
|
22
|
+
export * from './EvolutionManagedClickHouse';
|
|
22
23
|
export * from './EvolutionManagedSpark';
|
|
24
|
+
export * from './EvolutionManagedKafka';
|
|
@@ -1,7 +1,7 @@
|
|
|
1
|
-
import { ArenadataDbSVG, ArtifactRegistrySVG, BareMetalSVG, ContainerAppsSVG, EvoDnsSVG, EvolutionBiSVG, EvolutionComputeSVG, JupyterServersSVG, LoadBalancerSVG, ManagedKubernetesSVG, ManagedPostgreSqlSVG, MetastoreSVG, MlInferenceSVG, PublicIpSVG, RedisSVG, S3StorageSVG, SnatSVG, SparkSVG, TrinoSVG, } from '@cloud-ru/uikit-product-icons';
|
|
1
|
+
import { ArenadataDbSVG, ArtifactRegistrySVG, BareMetalSVG, ContainerAppsSVG, EvoDnsSVG, EvolutionBiSVG, EvolutionComputeSVG, JupyterServersSVG, LoadBalancerSVG, ManagedClickHouseSVG, ManagedKafkaSVG, ManagedKubernetesSVG, ManagedPostgreSqlSVG, MetastoreSVG, MlInferenceSVG, PublicIpSVG, RedisSVG, S3StorageSVG, SnatSVG, SparkSVG, TrinoSVG, } from '@cloud-ru/uikit-product-icons';
|
|
2
2
|
import { PLATFORM } from '../../../constants';
|
|
3
3
|
import { EVOLUTION_PRODUCT } from './constants';
|
|
4
|
-
import { EVOLUTION_ARENADATA_DB_FORM_CONFIG, EVOLUTION_ARTIFACT_REGISTRY, EVOLUTION_BARE_METAL_FORM_CONFIG, EVOLUTION_CLOUD_SERVER_FORM_CONFIG, EVOLUTION_CLOUD_SERVER_FREE_TIER_FORM_CONFIG, EVOLUTION_CONTAINER_APPS_CONFIG, EVOLUTION_CONTAINER_APPS_FREE_TIER_CONFIG, EVOLUTION_DNS_CONFIG, EVOLUTION_KUBERNETES_FORM_CONFIG, EVOLUTION_LOAD_BALANCER_CONFIG, EVOLUTION_MANAGED_BI, EVOLUTION_MANAGED_METASTORE_CONFIG, EVOLUTION_MANAGED_REDIS_CONFIG, EVOLUTION_MANAGED_SPARK_CONFIG, EVOLUTION_MANAGED_TRINO_CONFIG, EVOLUTION_ML_INFERENCE_FORM_CONFIG, EVOLUTION_NOTEBOOKS_CONFIG, EVOLUTION_POSTGRE_SQL_FORM_CONFIG, EVOLUTION_PUBLIC_IP_FORM_CONFIG, EVOLUTION_SNAT_GATEWAY_FORM_CONFIG, EVOLUTION_STORAGE_S3_FORM_CONFIG, EVOLUTION_STORAGE_S3_FREE_TIER_FORM_CONFIG, } from './product-config';
|
|
4
|
+
import { EVOLUTION_ARENADATA_DB_FORM_CONFIG, EVOLUTION_ARTIFACT_REGISTRY, EVOLUTION_BARE_METAL_FORM_CONFIG, EVOLUTION_CLOUD_SERVER_FORM_CONFIG, EVOLUTION_CLOUD_SERVER_FREE_TIER_FORM_CONFIG, EVOLUTION_CONTAINER_APPS_CONFIG, EVOLUTION_CONTAINER_APPS_FREE_TIER_CONFIG, EVOLUTION_DNS_CONFIG, EVOLUTION_KUBERNETES_FORM_CONFIG, EVOLUTION_LOAD_BALANCER_CONFIG, EVOLUTION_MANAGED_BI, EVOLUTION_MANAGED_CLICKHOUSE_CONFIG, EVOLUTION_MANAGED_KAFKA_CONFIG, EVOLUTION_MANAGED_METASTORE_CONFIG, EVOLUTION_MANAGED_REDIS_CONFIG, EVOLUTION_MANAGED_SPARK_CONFIG, EVOLUTION_MANAGED_TRINO_CONFIG, EVOLUTION_ML_INFERENCE_FORM_CONFIG, EVOLUTION_NOTEBOOKS_CONFIG, EVOLUTION_POSTGRE_SQL_FORM_CONFIG, EVOLUTION_PUBLIC_IP_FORM_CONFIG, EVOLUTION_SNAT_GATEWAY_FORM_CONFIG, EVOLUTION_STORAGE_S3_FORM_CONFIG, EVOLUTION_STORAGE_S3_FREE_TIER_FORM_CONFIG, } from './product-config';
|
|
5
5
|
export const EVOLUTION_PRODUCTS = {
|
|
6
6
|
[EVOLUTION_PRODUCT.EvolutionCloudServer]: {
|
|
7
7
|
id: EVOLUTION_PRODUCT.EvolutionCloudServer,
|
|
@@ -87,6 +87,16 @@ export const EVOLUTION_PRODUCTS = {
|
|
|
87
87
|
dataTestId: 'EvolutionManagedRedis',
|
|
88
88
|
enableConnectToConsole: true,
|
|
89
89
|
},
|
|
90
|
+
[EVOLUTION_PRODUCT.EvolutionManagedClickHouse]: {
|
|
91
|
+
id: EVOLUTION_PRODUCT.EvolutionManagedClickHouse,
|
|
92
|
+
platform: PLATFORM.Evolution,
|
|
93
|
+
label: 'Evolution Managed ClickHouse',
|
|
94
|
+
caption: 'Управляемая аналитическая СУБД в облаке на базе ClickHouse®',
|
|
95
|
+
formConfig: EVOLUTION_MANAGED_CLICKHOUSE_CONFIG,
|
|
96
|
+
icon: ManagedClickHouseSVG,
|
|
97
|
+
dataTestId: 'EvolutionManagedClickhouse',
|
|
98
|
+
enableConnectToConsole: true,
|
|
99
|
+
},
|
|
90
100
|
[EVOLUTION_PRODUCT.EvolutionLoadBalancer]: {
|
|
91
101
|
id: EVOLUTION_PRODUCT.EvolutionLoadBalancer,
|
|
92
102
|
platform: PLATFORM.Evolution,
|
|
@@ -97,6 +107,16 @@ export const EVOLUTION_PRODUCTS = {
|
|
|
97
107
|
dataTestId: 'EvolutionLoadBalancer',
|
|
98
108
|
enableConnectToConsole: true,
|
|
99
109
|
},
|
|
110
|
+
[EVOLUTION_PRODUCT.EvolutionManagedKafka]: {
|
|
111
|
+
id: EVOLUTION_PRODUCT.EvolutionManagedKafka,
|
|
112
|
+
platform: PLATFORM.Evolution,
|
|
113
|
+
label: 'Evolution Managed Kafka',
|
|
114
|
+
caption: 'Готовый кластер Apache Kafka® — сервис для потоковой обработки данных в реальном времени',
|
|
115
|
+
formConfig: EVOLUTION_MANAGED_KAFKA_CONFIG,
|
|
116
|
+
icon: ManagedKafkaSVG,
|
|
117
|
+
dataTestId: 'EvolutionManagedKafka',
|
|
118
|
+
enableConnectToConsole: true,
|
|
119
|
+
},
|
|
100
120
|
[EVOLUTION_PRODUCT.EvolutionStorageS3]: {
|
|
101
121
|
id: EVOLUTION_PRODUCT.EvolutionStorageS3,
|
|
102
122
|
platform: PLATFORM.Evolution,
|
package/dist/esm/constants.d.ts
CHANGED
|
@@ -15,6 +15,8 @@ export declare const CATEGORY: {
|
|
|
15
15
|
readonly Containerization: "containerization";
|
|
16
16
|
readonly Storage: "storage";
|
|
17
17
|
readonly Database: "database";
|
|
18
|
+
readonly Dataset: "dataset";
|
|
19
|
+
readonly Brokers: "brokers";
|
|
18
20
|
readonly Development: "development";
|
|
19
21
|
readonly Analytic: "analytic";
|
|
20
22
|
readonly ML: "ml-ai-tools";
|
package/dist/esm/constants.js
CHANGED
package/package.json
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@cloud-ru/uikit-product-calculator",
|
|
3
3
|
"title": "Calculator",
|
|
4
|
-
"version": "1.
|
|
4
|
+
"version": "1.5.0",
|
|
5
5
|
"sideEffects": [
|
|
6
6
|
"*.css",
|
|
7
7
|
"*.woff",
|
|
@@ -71,5 +71,5 @@
|
|
|
71
71
|
"devDependencies": {
|
|
72
72
|
"@types/lodash": "4.17.13"
|
|
73
73
|
},
|
|
74
|
-
"gitHead": "
|
|
74
|
+
"gitHead": "ca40a777977f3b0e82e768c4fa679548f09ec073"
|
|
75
75
|
}
|
|
@@ -103,6 +103,18 @@ export const EVOLUTION_CATALOG: CatalogConfig['catalog'] = {
|
|
|
103
103
|
EVOLUTION_PRODUCT.EvolutionManagedBI,
|
|
104
104
|
],
|
|
105
105
|
},
|
|
106
|
+
{
|
|
107
|
+
id: CATEGORY.Dataset,
|
|
108
|
+
label: 'Базы данных',
|
|
109
|
+
dataTestId: 'dataset',
|
|
110
|
+
visibleProducts: [EVOLUTION_PRODUCT.EvolutionManagedClickHouse],
|
|
111
|
+
},
|
|
112
|
+
{
|
|
113
|
+
id: CATEGORY.Brokers,
|
|
114
|
+
label: 'Брокеры сообщений',
|
|
115
|
+
dataTestId: 'brokers',
|
|
116
|
+
visibleProducts: [EVOLUTION_PRODUCT.EvolutionManagedKafka],
|
|
117
|
+
},
|
|
106
118
|
{
|
|
107
119
|
id: CATEGORY.ML,
|
|
108
120
|
label: 'ML/AI Инструменты',
|
|
@@ -18,7 +18,9 @@ export const EVOLUTION_PRODUCT = {
|
|
|
18
18
|
EvolutionManagedTrino: 'evolutionManagedTrino',
|
|
19
19
|
EvolutionManagedBI: 'evolutionManagedBI',
|
|
20
20
|
EvolutionManagedRedis: 'evolutionManagedRedis',
|
|
21
|
+
EvolutionManagedClickHouse: 'evolutionManagedClickhouse',
|
|
21
22
|
EvolutionManagedSpark: 'evolutionManagedSpark',
|
|
23
|
+
EvolutionManagedKafka: 'evolutionManagedKafka',
|
|
22
24
|
EvolutionLoadBalancer: 'evolutionLoadBalancer',
|
|
23
25
|
EvolutionNotebooks: 'evolutionNotebooks',
|
|
24
26
|
} as const;
|
|
@@ -0,0 +1,194 @@
|
|
|
1
|
+
import { CONTROL, FormConfig } from '../../../../components';
|
|
2
|
+
import { generateCpuItems, generateRamItems, getDisk } from '../../../utils';
|
|
3
|
+
|
|
4
|
+
const valueSingleNode = 'Single-node';
|
|
5
|
+
const valueSingleShard = 'Single-shard';
|
|
6
|
+
const valueMultiShard = 'Multi-shard';
|
|
7
|
+
|
|
8
|
+
const CPU = [4, 8];
|
|
9
|
+
const RAM = [16, 32];
|
|
10
|
+
|
|
11
|
+
const cpuToRamMap: Record<string, number[]> = {
|
|
12
|
+
'4': [16],
|
|
13
|
+
'8': [32],
|
|
14
|
+
};
|
|
15
|
+
|
|
16
|
+
const cpuConfigItems: {
|
|
17
|
+
[key: string]: {
|
|
18
|
+
value: string;
|
|
19
|
+
label: string;
|
|
20
|
+
}[];
|
|
21
|
+
} = {
|
|
22
|
+
[valueSingleNode]: generateCpuItems(CPU),
|
|
23
|
+
[valueSingleShard]: generateCpuItems(CPU),
|
|
24
|
+
[valueMultiShard]: generateCpuItems([CPU[0]]),
|
|
25
|
+
};
|
|
26
|
+
|
|
27
|
+
const ramConfigItems: {
|
|
28
|
+
[key: string]: number[];
|
|
29
|
+
} = {
|
|
30
|
+
[valueSingleNode]: RAM,
|
|
31
|
+
[valueSingleShard]: RAM,
|
|
32
|
+
[valueMultiShard]: [RAM[0]],
|
|
33
|
+
};
|
|
34
|
+
|
|
35
|
+
const instanceTypePartCards = [
|
|
36
|
+
{
|
|
37
|
+
value: valueSingleNode,
|
|
38
|
+
label: valueSingleNode,
|
|
39
|
+
description: 'Шард с одной репликой',
|
|
40
|
+
},
|
|
41
|
+
{
|
|
42
|
+
value: valueSingleShard,
|
|
43
|
+
label: valueSingleShard,
|
|
44
|
+
description: 'Шард с репликами',
|
|
45
|
+
},
|
|
46
|
+
{
|
|
47
|
+
value: valueMultiShard,
|
|
48
|
+
label: valueMultiShard,
|
|
49
|
+
description: 'Несколько шардов с репликами',
|
|
50
|
+
},
|
|
51
|
+
];
|
|
52
|
+
|
|
53
|
+
const shardQuantityItemsByInstantType: { [key: string]: number[] } = {
|
|
54
|
+
[valueSingleNode]: [1],
|
|
55
|
+
[valueSingleShard]: [1],
|
|
56
|
+
[valueMultiShard]: [3],
|
|
57
|
+
};
|
|
58
|
+
|
|
59
|
+
const hostQuantityItemsByInstantType: { [key: string]: number[] } = {
|
|
60
|
+
[valueSingleNode]: [1],
|
|
61
|
+
[valueSingleShard]: [3],
|
|
62
|
+
[valueMultiShard]: [3],
|
|
63
|
+
};
|
|
64
|
+
|
|
65
|
+
export const EVOLUTION_MANAGED_CLICKHOUSE_CONFIG: FormConfig = {
|
|
66
|
+
ui: ['instanceType', ['vCpuCoreCount', 'ramAmount'], ['shardQuantity', 'hostQuantity'], ['systemDisk']],
|
|
67
|
+
controls: {
|
|
68
|
+
instanceType: {
|
|
69
|
+
decoratorProps: {
|
|
70
|
+
label: 'Тип инстанса',
|
|
71
|
+
},
|
|
72
|
+
type: CONTROL.Carousel,
|
|
73
|
+
accessorKey: 'instanceType',
|
|
74
|
+
defaultValue: instanceTypePartCards[0].value,
|
|
75
|
+
items: instanceTypePartCards,
|
|
76
|
+
onChangeFn: (value, setValue) => {
|
|
77
|
+
if (value === valueMultiShard) {
|
|
78
|
+
setValue([
|
|
79
|
+
['instanceType', value],
|
|
80
|
+
['shardQuantity', '3'],
|
|
81
|
+
['hostQuantity', '3'],
|
|
82
|
+
]);
|
|
83
|
+
} else if (value === valueSingleShard) {
|
|
84
|
+
setValue([
|
|
85
|
+
['instanceType', value],
|
|
86
|
+
['shardQuantity', '1'],
|
|
87
|
+
['hostQuantity', '3'],
|
|
88
|
+
]);
|
|
89
|
+
} else {
|
|
90
|
+
setValue([
|
|
91
|
+
['instanceType', value],
|
|
92
|
+
['shardQuantity', '1'],
|
|
93
|
+
['hostQuantity', '1'],
|
|
94
|
+
]);
|
|
95
|
+
}
|
|
96
|
+
},
|
|
97
|
+
},
|
|
98
|
+
vCpuCoreCount: {
|
|
99
|
+
type: CONTROL.Segmented,
|
|
100
|
+
accessorKey: 'vCpuCoreCount',
|
|
101
|
+
watchedControls: { instanceType: 'instanceType' },
|
|
102
|
+
defaultValue: '4',
|
|
103
|
+
items: generateCpuItems(CPU),
|
|
104
|
+
decoratorProps: {
|
|
105
|
+
label: 'Количество ядер vCPU',
|
|
106
|
+
},
|
|
107
|
+
relateFn: ({ instanceType }) => {
|
|
108
|
+
const items = cpuConfigItems[instanceType];
|
|
109
|
+
|
|
110
|
+
if (items?.length > 0) {
|
|
111
|
+
return { items };
|
|
112
|
+
}
|
|
113
|
+
},
|
|
114
|
+
},
|
|
115
|
+
|
|
116
|
+
ramAmount: {
|
|
117
|
+
type: CONTROL.Segmented,
|
|
118
|
+
accessorKey: 'ramAmount',
|
|
119
|
+
watchedControls: { instanceType: 'instanceType', vCpuCoreCount: 'vCpuCoreCount' },
|
|
120
|
+
defaultValue: '16',
|
|
121
|
+
items: generateRamItems(RAM),
|
|
122
|
+
decoratorProps: {
|
|
123
|
+
label: 'Количество оперативной памяти (RAM)',
|
|
124
|
+
},
|
|
125
|
+
relateFn: ({ instanceType, vCpuCoreCount }) => {
|
|
126
|
+
const itemsByInstanceType = ramConfigItems[instanceType];
|
|
127
|
+
const itemsByCpu = new Set(cpuToRamMap[vCpuCoreCount as string]);
|
|
128
|
+
|
|
129
|
+
if (itemsByInstanceType?.length > 0) {
|
|
130
|
+
const resolvedItems = itemsByInstanceType.filter(item => itemsByCpu.has(item));
|
|
131
|
+
return {
|
|
132
|
+
items: generateRamItems(resolvedItems),
|
|
133
|
+
};
|
|
134
|
+
}
|
|
135
|
+
},
|
|
136
|
+
},
|
|
137
|
+
shardQuantity: {
|
|
138
|
+
type: CONTROL.Segmented,
|
|
139
|
+
decoratorProps: {
|
|
140
|
+
label: 'Количество шардов',
|
|
141
|
+
},
|
|
142
|
+
defaultValue: '1',
|
|
143
|
+
items: generateCpuItems([1]),
|
|
144
|
+
accessorKey: 'shardQuantity',
|
|
145
|
+
watchedControls: { instanceType: 'instanceType' },
|
|
146
|
+
relateFn: ({ instanceType }) => {
|
|
147
|
+
const items = shardQuantityItemsByInstantType[instanceType];
|
|
148
|
+
|
|
149
|
+
if (items?.length > 0) {
|
|
150
|
+
return {
|
|
151
|
+
items: generateCpuItems(items),
|
|
152
|
+
};
|
|
153
|
+
}
|
|
154
|
+
},
|
|
155
|
+
},
|
|
156
|
+
hostQuantity: {
|
|
157
|
+
type: CONTROL.Segmented,
|
|
158
|
+
decoratorProps: {
|
|
159
|
+
label: 'Количество хостов',
|
|
160
|
+
},
|
|
161
|
+
defaultValue: '1',
|
|
162
|
+
items: generateCpuItems([1]),
|
|
163
|
+
accessorKey: 'hostQuantity',
|
|
164
|
+
watchedControls: { instanceType: 'instanceType' },
|
|
165
|
+
relateFn: ({ instanceType }) => {
|
|
166
|
+
const items = hostQuantityItemsByInstantType[instanceType];
|
|
167
|
+
|
|
168
|
+
if (items?.length > 0) {
|
|
169
|
+
return {
|
|
170
|
+
items: generateCpuItems(items),
|
|
171
|
+
};
|
|
172
|
+
}
|
|
173
|
+
},
|
|
174
|
+
},
|
|
175
|
+
systemDisk: getDisk({
|
|
176
|
+
space: {
|
|
177
|
+
label: 'Диск',
|
|
178
|
+
accessorKey: 'diskCapacity',
|
|
179
|
+
defaultValue: 40,
|
|
180
|
+
uiProps: {
|
|
181
|
+
min: 40,
|
|
182
|
+
max: 16_384,
|
|
183
|
+
},
|
|
184
|
+
},
|
|
185
|
+
specification: {
|
|
186
|
+
accessorKey: 'diskType',
|
|
187
|
+
defaultValue: 'SSD',
|
|
188
|
+
uiProps: {
|
|
189
|
+
disabled: true,
|
|
190
|
+
},
|
|
191
|
+
},
|
|
192
|
+
}),
|
|
193
|
+
},
|
|
194
|
+
};
|
|
@@ -0,0 +1,75 @@
|
|
|
1
|
+
import { CONTROL, FormConfig } from '../../../../components';
|
|
2
|
+
import { generateCpuItems, generateRamItems, getDisk } from '../../../utils';
|
|
3
|
+
|
|
4
|
+
const CPU = [2, 4, 8];
|
|
5
|
+
const RAM = [4, 8, 16, 32];
|
|
6
|
+
|
|
7
|
+
const cpuToRamMap: Record<string, number[]> = {
|
|
8
|
+
'2': [4],
|
|
9
|
+
'4': [8, 16],
|
|
10
|
+
'8': [32],
|
|
11
|
+
};
|
|
12
|
+
|
|
13
|
+
const brokerQuantity = [1, 3, 5, 7];
|
|
14
|
+
|
|
15
|
+
export const EVOLUTION_MANAGED_KAFKA_CONFIG: FormConfig = {
|
|
16
|
+
ui: [['vCpuCoreCount', 'ramAmount'], ['brokerQuantity'], ['systemDisk']],
|
|
17
|
+
controls: {
|
|
18
|
+
vCpuCoreCount: {
|
|
19
|
+
type: CONTROL.Segmented,
|
|
20
|
+
accessorKey: 'vCpuCoreCount',
|
|
21
|
+
defaultValue: '2',
|
|
22
|
+
items: generateCpuItems(CPU),
|
|
23
|
+
decoratorProps: {
|
|
24
|
+
label: 'Количество ядер vCPU',
|
|
25
|
+
},
|
|
26
|
+
},
|
|
27
|
+
|
|
28
|
+
ramAmount: {
|
|
29
|
+
type: CONTROL.Segmented,
|
|
30
|
+
accessorKey: 'ramAmount',
|
|
31
|
+
watchedControls: { vCpuCoreCount: 'vCpuCoreCount' },
|
|
32
|
+
defaultValue: '4',
|
|
33
|
+
items: generateRamItems(RAM),
|
|
34
|
+
decoratorProps: {
|
|
35
|
+
label: 'Количество оперативной памяти (RAM)',
|
|
36
|
+
},
|
|
37
|
+
relateFn: ({ vCpuCoreCount }) => {
|
|
38
|
+
const itemsByCpu = cpuToRamMap[vCpuCoreCount as string];
|
|
39
|
+
|
|
40
|
+
if (itemsByCpu?.length > 0) {
|
|
41
|
+
return {
|
|
42
|
+
items: generateRamItems(itemsByCpu),
|
|
43
|
+
};
|
|
44
|
+
}
|
|
45
|
+
},
|
|
46
|
+
},
|
|
47
|
+
brokerQuantity: {
|
|
48
|
+
type: CONTROL.Segmented,
|
|
49
|
+
decoratorProps: {
|
|
50
|
+
label: 'Количество брокеров',
|
|
51
|
+
},
|
|
52
|
+
defaultValue: '1',
|
|
53
|
+
items: generateCpuItems(brokerQuantity),
|
|
54
|
+
accessorKey: 'brokerQuantity',
|
|
55
|
+
},
|
|
56
|
+
systemDisk: getDisk({
|
|
57
|
+
space: {
|
|
58
|
+
label: 'Диск',
|
|
59
|
+
accessorKey: 'diskCapacity',
|
|
60
|
+
defaultValue: 40,
|
|
61
|
+
uiProps: {
|
|
62
|
+
min: 40,
|
|
63
|
+
max: 16_384,
|
|
64
|
+
},
|
|
65
|
+
},
|
|
66
|
+
specification: {
|
|
67
|
+
accessorKey: 'diskType',
|
|
68
|
+
defaultValue: 'SSD',
|
|
69
|
+
uiProps: {
|
|
70
|
+
disabled: true,
|
|
71
|
+
},
|
|
72
|
+
},
|
|
73
|
+
}),
|
|
74
|
+
},
|
|
75
|
+
};
|
|
@@ -19,4 +19,6 @@ export * from './EvolutionDNS';
|
|
|
19
19
|
export * from './EvolutionLoadBalancer';
|
|
20
20
|
export * from './EvolutionManagedBI';
|
|
21
21
|
export * from './EvolutionManagedRedis';
|
|
22
|
+
export * from './EvolutionManagedClickHouse';
|
|
22
23
|
export * from './EvolutionManagedSpark';
|
|
24
|
+
export * from './EvolutionManagedKafka';
|
|
@@ -8,6 +8,8 @@ import {
|
|
|
8
8
|
EvolutionComputeSVG,
|
|
9
9
|
JupyterServersSVG,
|
|
10
10
|
LoadBalancerSVG,
|
|
11
|
+
ManagedClickHouseSVG,
|
|
12
|
+
ManagedKafkaSVG,
|
|
11
13
|
ManagedKubernetesSVG,
|
|
12
14
|
ManagedPostgreSqlSVG,
|
|
13
15
|
MetastoreSVG,
|
|
@@ -35,6 +37,8 @@ import {
|
|
|
35
37
|
EVOLUTION_KUBERNETES_FORM_CONFIG,
|
|
36
38
|
EVOLUTION_LOAD_BALANCER_CONFIG,
|
|
37
39
|
EVOLUTION_MANAGED_BI,
|
|
40
|
+
EVOLUTION_MANAGED_CLICKHOUSE_CONFIG,
|
|
41
|
+
EVOLUTION_MANAGED_KAFKA_CONFIG,
|
|
38
42
|
EVOLUTION_MANAGED_METASTORE_CONFIG,
|
|
39
43
|
EVOLUTION_MANAGED_REDIS_CONFIG,
|
|
40
44
|
EVOLUTION_MANAGED_SPARK_CONFIG,
|
|
@@ -133,6 +137,16 @@ export const EVOLUTION_PRODUCTS: CatalogConfig['products'] = {
|
|
|
133
137
|
dataTestId: 'EvolutionManagedRedis',
|
|
134
138
|
enableConnectToConsole: true,
|
|
135
139
|
},
|
|
140
|
+
[EVOLUTION_PRODUCT.EvolutionManagedClickHouse]: {
|
|
141
|
+
id: EVOLUTION_PRODUCT.EvolutionManagedClickHouse,
|
|
142
|
+
platform: PLATFORM.Evolution,
|
|
143
|
+
label: 'Evolution Managed ClickHouse',
|
|
144
|
+
caption: 'Управляемая аналитическая СУБД в облаке на базе ClickHouse®',
|
|
145
|
+
formConfig: EVOLUTION_MANAGED_CLICKHOUSE_CONFIG,
|
|
146
|
+
icon: ManagedClickHouseSVG,
|
|
147
|
+
dataTestId: 'EvolutionManagedClickhouse',
|
|
148
|
+
enableConnectToConsole: true,
|
|
149
|
+
},
|
|
136
150
|
[EVOLUTION_PRODUCT.EvolutionLoadBalancer]: {
|
|
137
151
|
id: EVOLUTION_PRODUCT.EvolutionLoadBalancer,
|
|
138
152
|
platform: PLATFORM.Evolution,
|
|
@@ -143,6 +157,16 @@ export const EVOLUTION_PRODUCTS: CatalogConfig['products'] = {
|
|
|
143
157
|
dataTestId: 'EvolutionLoadBalancer',
|
|
144
158
|
enableConnectToConsole: true,
|
|
145
159
|
},
|
|
160
|
+
[EVOLUTION_PRODUCT.EvolutionManagedKafka]: {
|
|
161
|
+
id: EVOLUTION_PRODUCT.EvolutionManagedKafka,
|
|
162
|
+
platform: PLATFORM.Evolution,
|
|
163
|
+
label: 'Evolution Managed Kafka',
|
|
164
|
+
caption: 'Готовый кластер Apache Kafka® — сервис для потоковой обработки данных в реальном времени',
|
|
165
|
+
formConfig: EVOLUTION_MANAGED_KAFKA_CONFIG,
|
|
166
|
+
icon: ManagedKafkaSVG,
|
|
167
|
+
dataTestId: 'EvolutionManagedKafka',
|
|
168
|
+
enableConnectToConsole: true,
|
|
169
|
+
},
|
|
146
170
|
[EVOLUTION_PRODUCT.EvolutionStorageS3]: {
|
|
147
171
|
id: EVOLUTION_PRODUCT.EvolutionStorageS3,
|
|
148
172
|
platform: PLATFORM.Evolution,
|
package/src/constants.ts
CHANGED