@pulumi/rancher2 6.2.0 → 6.2.1
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/package.json +2 -2
- package/types/input.d.ts +1874 -0
- package/types/output.d.ts +1874 -0
package/types/input.d.ts
CHANGED
|
@@ -131,6 +131,9 @@ export interface ClusterAgentEnvVar {
|
|
|
131
131
|
* The name of the Cluster (string)
|
|
132
132
|
*/
|
|
133
133
|
name: pulumi.Input<string>;
|
|
134
|
+
/**
|
|
135
|
+
* The GKE taint value (string)
|
|
136
|
+
*/
|
|
134
137
|
value: pulumi.Input<string>;
|
|
135
138
|
}
|
|
136
139
|
export interface ClusterAksConfig {
|
|
@@ -582,10 +585,25 @@ export interface ClusterClusterAgentDeploymentCustomization {
|
|
|
582
585
|
overrideResourceRequirements?: pulumi.Input<pulumi.Input<inputs.ClusterClusterAgentDeploymentCustomizationOverrideResourceRequirement>[]>;
|
|
583
586
|
}
|
|
584
587
|
export interface ClusterClusterAgentDeploymentCustomizationAppendToleration {
|
|
588
|
+
/**
|
|
589
|
+
* The GKE taint effect (string)
|
|
590
|
+
*/
|
|
585
591
|
effect?: pulumi.Input<string>;
|
|
592
|
+
/**
|
|
593
|
+
* The GKE taint key (string)
|
|
594
|
+
*/
|
|
586
595
|
key: pulumi.Input<string>;
|
|
596
|
+
/**
|
|
597
|
+
* The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
|
|
598
|
+
*/
|
|
587
599
|
operator?: pulumi.Input<string>;
|
|
600
|
+
/**
|
|
601
|
+
* The toleration seconds (int)
|
|
602
|
+
*/
|
|
588
603
|
seconds?: pulumi.Input<number>;
|
|
604
|
+
/**
|
|
605
|
+
* The GKE taint value (string)
|
|
606
|
+
*/
|
|
589
607
|
value?: pulumi.Input<string>;
|
|
590
608
|
}
|
|
591
609
|
export interface ClusterClusterAgentDeploymentCustomizationOverrideResourceRequirement {
|
|
@@ -607,8 +625,17 @@ export interface ClusterClusterAgentDeploymentCustomizationOverrideResourceRequi
|
|
|
607
625
|
memoryRequest?: pulumi.Input<string>;
|
|
608
626
|
}
|
|
609
627
|
export interface ClusterClusterAuthEndpoint {
|
|
628
|
+
/**
|
|
629
|
+
* CA certs for the authorized cluster endpoint (string)
|
|
630
|
+
*/
|
|
610
631
|
caCerts?: pulumi.Input<string>;
|
|
632
|
+
/**
|
|
633
|
+
* Enable the authorized cluster endpoint. Default `true` (bool)
|
|
634
|
+
*/
|
|
611
635
|
enabled?: pulumi.Input<boolean>;
|
|
636
|
+
/**
|
|
637
|
+
* FQDN for the authorized cluster endpoint (string)
|
|
638
|
+
*/
|
|
612
639
|
fqdn?: pulumi.Input<string>;
|
|
613
640
|
}
|
|
614
641
|
export interface ClusterClusterMonitoringInput {
|
|
@@ -631,13 +658,25 @@ export interface ClusterClusterRegistrationToken {
|
|
|
631
658
|
[key: string]: any;
|
|
632
659
|
}>;
|
|
633
660
|
clusterId?: pulumi.Input<string>;
|
|
661
|
+
/**
|
|
662
|
+
* Command to execute in a imported k8s cluster (string)
|
|
663
|
+
*/
|
|
634
664
|
command?: pulumi.Input<string>;
|
|
635
665
|
/**
|
|
636
666
|
* (Computed) The ID of the resource (string)
|
|
637
667
|
*/
|
|
638
668
|
id?: pulumi.Input<string>;
|
|
669
|
+
/**
|
|
670
|
+
* Insecure command to execute in a imported k8s cluster (string)
|
|
671
|
+
*/
|
|
639
672
|
insecureCommand?: pulumi.Input<string>;
|
|
673
|
+
/**
|
|
674
|
+
* Insecure node command to execute in a imported k8s cluster (string)
|
|
675
|
+
*/
|
|
640
676
|
insecureNodeCommand?: pulumi.Input<string>;
|
|
677
|
+
/**
|
|
678
|
+
* Insecure windows command to execute in a imported k8s cluster (string)
|
|
679
|
+
*/
|
|
641
680
|
insecureWindowsNodeCommand?: pulumi.Input<string>;
|
|
642
681
|
/**
|
|
643
682
|
* Labels for the Cluster (map)
|
|
@@ -645,13 +684,22 @@ export interface ClusterClusterRegistrationToken {
|
|
|
645
684
|
labels?: pulumi.Input<{
|
|
646
685
|
[key: string]: any;
|
|
647
686
|
}>;
|
|
687
|
+
/**
|
|
688
|
+
* K8s manifest url to execute with `kubectl` to import an existing k8s cluster (string)
|
|
689
|
+
*/
|
|
648
690
|
manifestUrl?: pulumi.Input<string>;
|
|
649
691
|
/**
|
|
650
692
|
* The name of the Cluster (string)
|
|
651
693
|
*/
|
|
652
694
|
name?: pulumi.Input<string>;
|
|
695
|
+
/**
|
|
696
|
+
* Node command to execute in linux nodes for custom k8s cluster (string)
|
|
697
|
+
*/
|
|
653
698
|
nodeCommand?: pulumi.Input<string>;
|
|
654
699
|
token?: pulumi.Input<string>;
|
|
700
|
+
/**
|
|
701
|
+
* Node command to execute in windows nodes for custom k8s cluster (string)
|
|
702
|
+
*/
|
|
655
703
|
windowsNodeCommand?: pulumi.Input<string>;
|
|
656
704
|
}
|
|
657
705
|
export interface ClusterClusterTemplateAnswers {
|
|
@@ -947,10 +995,25 @@ export interface ClusterFleetAgentDeploymentCustomization {
|
|
|
947
995
|
overrideResourceRequirements?: pulumi.Input<pulumi.Input<inputs.ClusterFleetAgentDeploymentCustomizationOverrideResourceRequirement>[]>;
|
|
948
996
|
}
|
|
949
997
|
export interface ClusterFleetAgentDeploymentCustomizationAppendToleration {
|
|
998
|
+
/**
|
|
999
|
+
* The GKE taint effect (string)
|
|
1000
|
+
*/
|
|
950
1001
|
effect?: pulumi.Input<string>;
|
|
1002
|
+
/**
|
|
1003
|
+
* The GKE taint key (string)
|
|
1004
|
+
*/
|
|
951
1005
|
key: pulumi.Input<string>;
|
|
1006
|
+
/**
|
|
1007
|
+
* The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
|
|
1008
|
+
*/
|
|
952
1009
|
operator?: pulumi.Input<string>;
|
|
1010
|
+
/**
|
|
1011
|
+
* The toleration seconds (int)
|
|
1012
|
+
*/
|
|
953
1013
|
seconds?: pulumi.Input<number>;
|
|
1014
|
+
/**
|
|
1015
|
+
* The GKE taint value (string)
|
|
1016
|
+
*/
|
|
954
1017
|
value?: pulumi.Input<string>;
|
|
955
1018
|
}
|
|
956
1019
|
export interface ClusterFleetAgentDeploymentCustomizationOverrideResourceRequirement {
|
|
@@ -1442,8 +1505,17 @@ export interface ClusterGkeConfigV2NodePoolConfig {
|
|
|
1442
1505
|
taints?: pulumi.Input<pulumi.Input<inputs.ClusterGkeConfigV2NodePoolConfigTaint>[]>;
|
|
1443
1506
|
}
|
|
1444
1507
|
export interface ClusterGkeConfigV2NodePoolConfigTaint {
|
|
1508
|
+
/**
|
|
1509
|
+
* The GKE taint effect (string)
|
|
1510
|
+
*/
|
|
1445
1511
|
effect: pulumi.Input<string>;
|
|
1512
|
+
/**
|
|
1513
|
+
* The GKE taint key (string)
|
|
1514
|
+
*/
|
|
1446
1515
|
key: pulumi.Input<string>;
|
|
1516
|
+
/**
|
|
1517
|
+
* The GKE taint value (string)
|
|
1518
|
+
*/
|
|
1447
1519
|
value: pulumi.Input<string>;
|
|
1448
1520
|
}
|
|
1449
1521
|
export interface ClusterGkeConfigV2NodePoolManagement {
|
|
@@ -1681,7 +1753,13 @@ export interface ClusterRkeConfig {
|
|
|
1681
1753
|
* RKE bastion host
|
|
1682
1754
|
*/
|
|
1683
1755
|
bastionHost?: pulumi.Input<inputs.ClusterRkeConfigBastionHost>;
|
|
1756
|
+
/**
|
|
1757
|
+
* RKE options for Calico network provider (string)
|
|
1758
|
+
*/
|
|
1684
1759
|
cloudProvider?: pulumi.Input<inputs.ClusterRkeConfigCloudProvider>;
|
|
1760
|
+
/**
|
|
1761
|
+
* RKE dns add-on. For Rancher v2.2.x (list maxitems:1)
|
|
1762
|
+
*/
|
|
1685
1763
|
dns?: pulumi.Input<inputs.ClusterRkeConfigDns>;
|
|
1686
1764
|
/**
|
|
1687
1765
|
* Enable/disable using cri-dockerd
|
|
@@ -1745,174 +1823,522 @@ export interface ClusterRkeConfig {
|
|
|
1745
1823
|
winPrefixPath?: pulumi.Input<string>;
|
|
1746
1824
|
}
|
|
1747
1825
|
export interface ClusterRkeConfigAuthentication {
|
|
1826
|
+
/**
|
|
1827
|
+
* RKE sans for authentication ([]string)
|
|
1828
|
+
*/
|
|
1748
1829
|
sans?: pulumi.Input<pulumi.Input<string>[]>;
|
|
1830
|
+
/**
|
|
1831
|
+
* Monitoring deployment update strategy (string)
|
|
1832
|
+
*/
|
|
1749
1833
|
strategy?: pulumi.Input<string>;
|
|
1750
1834
|
}
|
|
1751
1835
|
export interface ClusterRkeConfigAuthorization {
|
|
1836
|
+
/**
|
|
1837
|
+
* The AKS node group mode. Default: `System` (string)
|
|
1838
|
+
*/
|
|
1752
1839
|
mode?: pulumi.Input<string>;
|
|
1840
|
+
/**
|
|
1841
|
+
* RKE options for network (map)
|
|
1842
|
+
*/
|
|
1753
1843
|
options?: pulumi.Input<{
|
|
1754
1844
|
[key: string]: any;
|
|
1755
1845
|
}>;
|
|
1756
1846
|
}
|
|
1757
1847
|
export interface ClusterRkeConfigBastionHost {
|
|
1848
|
+
/**
|
|
1849
|
+
* Address ip for node (string)
|
|
1850
|
+
*/
|
|
1758
1851
|
address: pulumi.Input<string>;
|
|
1852
|
+
/**
|
|
1853
|
+
* Port for node. Default `22` (string)
|
|
1854
|
+
*/
|
|
1759
1855
|
port?: pulumi.Input<string>;
|
|
1856
|
+
/**
|
|
1857
|
+
* Use ssh agent auth. Default `false` (bool)
|
|
1858
|
+
*/
|
|
1760
1859
|
sshAgentAuth?: pulumi.Input<boolean>;
|
|
1860
|
+
/**
|
|
1861
|
+
* Node SSH private key (string)
|
|
1862
|
+
*/
|
|
1761
1863
|
sshKey?: pulumi.Input<string>;
|
|
1864
|
+
/**
|
|
1865
|
+
* Node SSH private key path (string)
|
|
1866
|
+
*/
|
|
1762
1867
|
sshKeyPath?: pulumi.Input<string>;
|
|
1868
|
+
/**
|
|
1869
|
+
* Registry user (string)
|
|
1870
|
+
*/
|
|
1763
1871
|
user: pulumi.Input<string>;
|
|
1764
1872
|
}
|
|
1765
1873
|
export interface ClusterRkeConfigCloudProvider {
|
|
1874
|
+
/**
|
|
1875
|
+
* RKE AWS Cloud Provider config for Cloud Provider [rke-aws-cloud-provider](https://rancher.com/docs/rke/latest/en/config-options/cloud-providers/aws/) (list maxitems:1)
|
|
1876
|
+
*/
|
|
1766
1877
|
awsCloudProvider?: pulumi.Input<inputs.ClusterRkeConfigCloudProviderAwsCloudProvider>;
|
|
1878
|
+
/**
|
|
1879
|
+
* RKE Azure Cloud Provider config for Cloud Provider [rke-azure-cloud-provider](https://rancher.com/docs/rke/latest/en/config-options/cloud-providers/azure/) (list maxitems:1)
|
|
1880
|
+
*/
|
|
1767
1881
|
azureCloudProvider?: pulumi.Input<inputs.ClusterRkeConfigCloudProviderAzureCloudProvider>;
|
|
1882
|
+
/**
|
|
1883
|
+
* RKE Custom Cloud Provider config for Cloud Provider (string)
|
|
1884
|
+
*/
|
|
1768
1885
|
customCloudProvider?: pulumi.Input<string>;
|
|
1769
1886
|
/**
|
|
1770
1887
|
* The name of the Cluster (string)
|
|
1771
1888
|
*/
|
|
1772
1889
|
name?: pulumi.Input<string>;
|
|
1890
|
+
/**
|
|
1891
|
+
* RKE Openstack Cloud Provider config for Cloud Provider [rke-openstack-cloud-provider](https://rancher.com/docs/rke/latest/en/config-options/cloud-providers/openstack/) (list maxitems:1)
|
|
1892
|
+
*/
|
|
1773
1893
|
openstackCloudProvider?: pulumi.Input<inputs.ClusterRkeConfigCloudProviderOpenstackCloudProvider>;
|
|
1894
|
+
/**
|
|
1895
|
+
* RKE Vsphere Cloud Provider config for Cloud Provider [rke-vsphere-cloud-provider](https://rancher.com/docs/rke/latest/en/config-options/cloud-providers/vsphere/) Extra argument `name` is required on `virtualCenter` configuration. (list maxitems:1)
|
|
1896
|
+
*/
|
|
1774
1897
|
vsphereCloudProvider?: pulumi.Input<inputs.ClusterRkeConfigCloudProviderVsphereCloudProvider>;
|
|
1775
1898
|
}
|
|
1776
1899
|
export interface ClusterRkeConfigCloudProviderAwsCloudProvider {
|
|
1900
|
+
/**
|
|
1901
|
+
* (list maxitems:1)
|
|
1902
|
+
*/
|
|
1777
1903
|
global?: pulumi.Input<inputs.ClusterRkeConfigCloudProviderAwsCloudProviderGlobal>;
|
|
1904
|
+
/**
|
|
1905
|
+
* (list)
|
|
1906
|
+
*/
|
|
1778
1907
|
serviceOverrides?: pulumi.Input<pulumi.Input<inputs.ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverride>[]>;
|
|
1779
1908
|
}
|
|
1780
1909
|
export interface ClusterRkeConfigCloudProviderAwsCloudProviderGlobal {
|
|
1910
|
+
/**
|
|
1911
|
+
* Default `false` (bool)
|
|
1912
|
+
*/
|
|
1781
1913
|
disableSecurityGroupIngress?: pulumi.Input<boolean>;
|
|
1914
|
+
/**
|
|
1915
|
+
* Default `false` (bool)
|
|
1916
|
+
*/
|
|
1782
1917
|
disableStrictZoneCheck?: pulumi.Input<boolean>;
|
|
1918
|
+
/**
|
|
1919
|
+
* (string)
|
|
1920
|
+
*/
|
|
1783
1921
|
elbSecurityGroup?: pulumi.Input<string>;
|
|
1922
|
+
/**
|
|
1923
|
+
* (string)
|
|
1924
|
+
*/
|
|
1784
1925
|
kubernetesClusterId?: pulumi.Input<string>;
|
|
1926
|
+
/**
|
|
1927
|
+
* (string)
|
|
1928
|
+
*/
|
|
1785
1929
|
kubernetesClusterTag?: pulumi.Input<string>;
|
|
1930
|
+
/**
|
|
1931
|
+
* (string)
|
|
1932
|
+
*/
|
|
1786
1933
|
roleArn?: pulumi.Input<string>;
|
|
1934
|
+
/**
|
|
1935
|
+
* (string)
|
|
1936
|
+
*/
|
|
1787
1937
|
routeTableId?: pulumi.Input<string>;
|
|
1938
|
+
/**
|
|
1939
|
+
* (string)
|
|
1940
|
+
*/
|
|
1788
1941
|
subnetId?: pulumi.Input<string>;
|
|
1942
|
+
/**
|
|
1943
|
+
* (string)
|
|
1944
|
+
*/
|
|
1789
1945
|
vpc?: pulumi.Input<string>;
|
|
1946
|
+
/**
|
|
1947
|
+
* The GKE cluster zone. Required if `region` not set (string)
|
|
1948
|
+
*/
|
|
1790
1949
|
zone?: pulumi.Input<string>;
|
|
1791
1950
|
}
|
|
1792
1951
|
export interface ClusterRkeConfigCloudProviderAwsCloudProviderServiceOverride {
|
|
1952
|
+
/**
|
|
1953
|
+
* The availability domain within the region to host the cluster. See [here](https://docs.cloud.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm) for a list of region names. (string)
|
|
1954
|
+
*/
|
|
1793
1955
|
region?: pulumi.Input<string>;
|
|
1956
|
+
/**
|
|
1957
|
+
* (string)
|
|
1958
|
+
*/
|
|
1794
1959
|
service: pulumi.Input<string>;
|
|
1960
|
+
/**
|
|
1961
|
+
* (string)
|
|
1962
|
+
*/
|
|
1795
1963
|
signingMethod?: pulumi.Input<string>;
|
|
1964
|
+
/**
|
|
1965
|
+
* (string)
|
|
1966
|
+
*/
|
|
1796
1967
|
signingName?: pulumi.Input<string>;
|
|
1968
|
+
/**
|
|
1969
|
+
* (string)
|
|
1970
|
+
*/
|
|
1797
1971
|
signingRegion?: pulumi.Input<string>;
|
|
1972
|
+
/**
|
|
1973
|
+
* Registry URL (string)
|
|
1974
|
+
*/
|
|
1798
1975
|
url?: pulumi.Input<string>;
|
|
1799
1976
|
}
|
|
1800
1977
|
export interface ClusterRkeConfigCloudProviderAzureCloudProvider {
|
|
1978
|
+
/**
|
|
1979
|
+
* (string)
|
|
1980
|
+
*/
|
|
1801
1981
|
aadClientCertPassword?: pulumi.Input<string>;
|
|
1982
|
+
/**
|
|
1983
|
+
* (string)
|
|
1984
|
+
*/
|
|
1802
1985
|
aadClientCertPath?: pulumi.Input<string>;
|
|
1986
|
+
/**
|
|
1987
|
+
* (string)
|
|
1988
|
+
*/
|
|
1803
1989
|
aadClientId: pulumi.Input<string>;
|
|
1990
|
+
/**
|
|
1991
|
+
* (string)
|
|
1992
|
+
*/
|
|
1804
1993
|
aadClientSecret: pulumi.Input<string>;
|
|
1994
|
+
/**
|
|
1995
|
+
* (string)
|
|
1996
|
+
*/
|
|
1805
1997
|
cloud?: pulumi.Input<string>;
|
|
1998
|
+
/**
|
|
1999
|
+
* (bool)
|
|
2000
|
+
*/
|
|
1806
2001
|
cloudProviderBackoff?: pulumi.Input<boolean>;
|
|
2002
|
+
/**
|
|
2003
|
+
* (int)
|
|
2004
|
+
*/
|
|
1807
2005
|
cloudProviderBackoffDuration?: pulumi.Input<number>;
|
|
2006
|
+
/**
|
|
2007
|
+
* (int)
|
|
2008
|
+
*/
|
|
1808
2009
|
cloudProviderBackoffExponent?: pulumi.Input<number>;
|
|
2010
|
+
/**
|
|
2011
|
+
* (int)
|
|
2012
|
+
*/
|
|
1809
2013
|
cloudProviderBackoffJitter?: pulumi.Input<number>;
|
|
2014
|
+
/**
|
|
2015
|
+
* (int)
|
|
2016
|
+
*/
|
|
1810
2017
|
cloudProviderBackoffRetries?: pulumi.Input<number>;
|
|
2018
|
+
/**
|
|
2019
|
+
* (bool)
|
|
2020
|
+
*/
|
|
1811
2021
|
cloudProviderRateLimit?: pulumi.Input<boolean>;
|
|
2022
|
+
/**
|
|
2023
|
+
* (int)
|
|
2024
|
+
*/
|
|
1812
2025
|
cloudProviderRateLimitBucket?: pulumi.Input<number>;
|
|
2026
|
+
/**
|
|
2027
|
+
* (int)
|
|
2028
|
+
*/
|
|
1813
2029
|
cloudProviderRateLimitQps?: pulumi.Input<number>;
|
|
1814
2030
|
/**
|
|
1815
2031
|
* Load balancer type (basic | standard). Must be standard for auto-scaling
|
|
1816
2032
|
*/
|
|
1817
2033
|
loadBalancerSku?: pulumi.Input<string>;
|
|
2034
|
+
/**
|
|
2035
|
+
* Azure Kubernetes cluster location. Default `eastus` (string)
|
|
2036
|
+
*/
|
|
1818
2037
|
location?: pulumi.Input<string>;
|
|
2038
|
+
/**
|
|
2039
|
+
* (int)
|
|
2040
|
+
*/
|
|
1819
2041
|
maximumLoadBalancerRuleCount?: pulumi.Input<number>;
|
|
2042
|
+
/**
|
|
2043
|
+
* (string)
|
|
2044
|
+
*/
|
|
1820
2045
|
primaryAvailabilitySetName?: pulumi.Input<string>;
|
|
2046
|
+
/**
|
|
2047
|
+
* (string)
|
|
2048
|
+
*/
|
|
1821
2049
|
primaryScaleSetName?: pulumi.Input<string>;
|
|
2050
|
+
/**
|
|
2051
|
+
* The AKS resource group (string)
|
|
2052
|
+
*/
|
|
1822
2053
|
resourceGroup?: pulumi.Input<string>;
|
|
2054
|
+
/**
|
|
2055
|
+
* (string)
|
|
2056
|
+
*/
|
|
1823
2057
|
routeTableName?: pulumi.Input<string>;
|
|
2058
|
+
/**
|
|
2059
|
+
* (string)
|
|
2060
|
+
*/
|
|
1824
2061
|
securityGroupName?: pulumi.Input<string>;
|
|
2062
|
+
/**
|
|
2063
|
+
* (string)
|
|
2064
|
+
*/
|
|
1825
2065
|
subnetName?: pulumi.Input<string>;
|
|
2066
|
+
/**
|
|
2067
|
+
* Subscription credentials which uniquely identify Microsoft Azure subscription (string)
|
|
2068
|
+
*/
|
|
1826
2069
|
subscriptionId: pulumi.Input<string>;
|
|
2070
|
+
/**
|
|
2071
|
+
* Azure tenant ID to use (string)
|
|
2072
|
+
*/
|
|
1827
2073
|
tenantId: pulumi.Input<string>;
|
|
2074
|
+
/**
|
|
2075
|
+
* (bool)
|
|
2076
|
+
*/
|
|
1828
2077
|
useInstanceMetadata?: pulumi.Input<boolean>;
|
|
2078
|
+
/**
|
|
2079
|
+
* (bool)
|
|
2080
|
+
*/
|
|
1829
2081
|
useManagedIdentityExtension?: pulumi.Input<boolean>;
|
|
2082
|
+
/**
|
|
2083
|
+
* (string)
|
|
2084
|
+
*/
|
|
1830
2085
|
vmType?: pulumi.Input<string>;
|
|
2086
|
+
/**
|
|
2087
|
+
* (string)
|
|
2088
|
+
*/
|
|
1831
2089
|
vnetName?: pulumi.Input<string>;
|
|
2090
|
+
/**
|
|
2091
|
+
* (string)
|
|
2092
|
+
*/
|
|
1832
2093
|
vnetResourceGroup?: pulumi.Input<string>;
|
|
1833
2094
|
}
|
|
1834
2095
|
export interface ClusterRkeConfigCloudProviderOpenstackCloudProvider {
|
|
2096
|
+
/**
|
|
2097
|
+
* (list maxitems:1)
|
|
2098
|
+
*/
|
|
1835
2099
|
blockStorage?: pulumi.Input<inputs.ClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorage>;
|
|
2100
|
+
/**
|
|
2101
|
+
* (list maxitems:1)
|
|
2102
|
+
*/
|
|
1836
2103
|
global: pulumi.Input<inputs.ClusterRkeConfigCloudProviderOpenstackCloudProviderGlobal>;
|
|
2104
|
+
/**
|
|
2105
|
+
* (list maxitems:1)
|
|
2106
|
+
*/
|
|
1837
2107
|
loadBalancer?: pulumi.Input<inputs.ClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer>;
|
|
2108
|
+
/**
|
|
2109
|
+
* (list maxitems:1)
|
|
2110
|
+
*/
|
|
1838
2111
|
metadata?: pulumi.Input<inputs.ClusterRkeConfigCloudProviderOpenstackCloudProviderMetadata>;
|
|
2112
|
+
/**
|
|
2113
|
+
* (list maxitems:1)
|
|
2114
|
+
*/
|
|
1839
2115
|
route?: pulumi.Input<inputs.ClusterRkeConfigCloudProviderOpenstackCloudProviderRoute>;
|
|
1840
2116
|
}
|
|
1841
2117
|
export interface ClusterRkeConfigCloudProviderOpenstackCloudProviderBlockStorage {
|
|
2118
|
+
/**
|
|
2119
|
+
* (string)
|
|
2120
|
+
*/
|
|
1842
2121
|
bsVersion?: pulumi.Input<string>;
|
|
2122
|
+
/**
|
|
2123
|
+
* (string)
|
|
2124
|
+
*/
|
|
1843
2125
|
ignoreVolumeAz?: pulumi.Input<boolean>;
|
|
2126
|
+
/**
|
|
2127
|
+
* (string)
|
|
2128
|
+
*/
|
|
1844
2129
|
trustDevicePath?: pulumi.Input<boolean>;
|
|
1845
2130
|
}
|
|
1846
2131
|
export interface ClusterRkeConfigCloudProviderOpenstackCloudProviderGlobal {
|
|
2132
|
+
/**
|
|
2133
|
+
* (string)
|
|
2134
|
+
*/
|
|
1847
2135
|
authUrl: pulumi.Input<string>;
|
|
2136
|
+
/**
|
|
2137
|
+
* (string)
|
|
2138
|
+
*/
|
|
1848
2139
|
caFile?: pulumi.Input<string>;
|
|
2140
|
+
/**
|
|
2141
|
+
* Required if `domainName` not provided. (string)
|
|
2142
|
+
*/
|
|
1849
2143
|
domainId?: pulumi.Input<string>;
|
|
2144
|
+
/**
|
|
2145
|
+
* Required if `domainId` not provided. (string)
|
|
2146
|
+
*/
|
|
1850
2147
|
domainName?: pulumi.Input<string>;
|
|
2148
|
+
/**
|
|
2149
|
+
* Registry password (string)
|
|
2150
|
+
*/
|
|
1851
2151
|
password: pulumi.Input<string>;
|
|
2152
|
+
/**
|
|
2153
|
+
* The availability domain within the region to host the cluster. See [here](https://docs.cloud.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm) for a list of region names. (string)
|
|
2154
|
+
*/
|
|
1852
2155
|
region?: pulumi.Input<string>;
|
|
2156
|
+
/**
|
|
2157
|
+
* Azure tenant ID to use (string)
|
|
2158
|
+
*/
|
|
1853
2159
|
tenantId?: pulumi.Input<string>;
|
|
2160
|
+
/**
|
|
2161
|
+
* Required if `tenantId` not provided. (string)
|
|
2162
|
+
*/
|
|
1854
2163
|
tenantName?: pulumi.Input<string>;
|
|
2164
|
+
/**
|
|
2165
|
+
* (string)
|
|
2166
|
+
*/
|
|
1855
2167
|
trustId?: pulumi.Input<string>;
|
|
2168
|
+
/**
|
|
2169
|
+
* (string)
|
|
2170
|
+
*/
|
|
1856
2171
|
username: pulumi.Input<string>;
|
|
1857
2172
|
}
|
|
1858
2173
|
export interface ClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer {
|
|
2174
|
+
/**
|
|
2175
|
+
* (bool)
|
|
2176
|
+
*/
|
|
1859
2177
|
createMonitor?: pulumi.Input<boolean>;
|
|
2178
|
+
/**
|
|
2179
|
+
* (string)
|
|
2180
|
+
*/
|
|
1860
2181
|
floatingNetworkId?: pulumi.Input<string>;
|
|
2182
|
+
/**
|
|
2183
|
+
* (string)
|
|
2184
|
+
*/
|
|
1861
2185
|
lbMethod?: pulumi.Input<string>;
|
|
2186
|
+
/**
|
|
2187
|
+
* (string)
|
|
2188
|
+
*/
|
|
1862
2189
|
lbProvider?: pulumi.Input<string>;
|
|
2190
|
+
/**
|
|
2191
|
+
* (string)
|
|
2192
|
+
*/
|
|
1863
2193
|
lbVersion?: pulumi.Input<string>;
|
|
2194
|
+
/**
|
|
2195
|
+
* (bool)
|
|
2196
|
+
*/
|
|
1864
2197
|
manageSecurityGroups?: pulumi.Input<boolean>;
|
|
2198
|
+
/**
|
|
2199
|
+
* Default `60s` (string)
|
|
2200
|
+
*/
|
|
1865
2201
|
monitorDelay?: pulumi.Input<string>;
|
|
2202
|
+
/**
|
|
2203
|
+
* Default 5 (int)
|
|
2204
|
+
*/
|
|
1866
2205
|
monitorMaxRetries?: pulumi.Input<number>;
|
|
2206
|
+
/**
|
|
2207
|
+
* Default `30s` (string)
|
|
2208
|
+
*/
|
|
1867
2209
|
monitorTimeout?: pulumi.Input<string>;
|
|
2210
|
+
/**
|
|
2211
|
+
* (string)
|
|
2212
|
+
*/
|
|
1868
2213
|
subnetId?: pulumi.Input<string>;
|
|
2214
|
+
/**
|
|
2215
|
+
* (bool)
|
|
2216
|
+
*/
|
|
1869
2217
|
useOctavia?: pulumi.Input<boolean>;
|
|
1870
2218
|
}
|
|
1871
2219
|
export interface ClusterRkeConfigCloudProviderOpenstackCloudProviderMetadata {
|
|
2220
|
+
/**
|
|
2221
|
+
* (int)
|
|
2222
|
+
*/
|
|
1872
2223
|
requestTimeout?: pulumi.Input<number>;
|
|
2224
|
+
/**
|
|
2225
|
+
* (string)
|
|
2226
|
+
*/
|
|
1873
2227
|
searchOrder?: pulumi.Input<string>;
|
|
1874
2228
|
}
|
|
1875
2229
|
export interface ClusterRkeConfigCloudProviderOpenstackCloudProviderRoute {
|
|
2230
|
+
/**
|
|
2231
|
+
* (string)
|
|
2232
|
+
*/
|
|
1876
2233
|
routerId?: pulumi.Input<string>;
|
|
1877
2234
|
}
|
|
1878
2235
|
export interface ClusterRkeConfigCloudProviderVsphereCloudProvider {
|
|
2236
|
+
/**
|
|
2237
|
+
* (list maxitems:1)
|
|
2238
|
+
*/
|
|
1879
2239
|
disk?: pulumi.Input<inputs.ClusterRkeConfigCloudProviderVsphereCloudProviderDisk>;
|
|
2240
|
+
/**
|
|
2241
|
+
* (list maxitems:1)
|
|
2242
|
+
*/
|
|
1880
2243
|
global?: pulumi.Input<inputs.ClusterRkeConfigCloudProviderVsphereCloudProviderGlobal>;
|
|
2244
|
+
/**
|
|
2245
|
+
* The GKE cluster network. Required for create new cluster (string)
|
|
2246
|
+
*/
|
|
1881
2247
|
network?: pulumi.Input<inputs.ClusterRkeConfigCloudProviderVsphereCloudProviderNetwork>;
|
|
2248
|
+
/**
|
|
2249
|
+
* (List)
|
|
2250
|
+
*/
|
|
1882
2251
|
virtualCenters: pulumi.Input<pulumi.Input<inputs.ClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenter>[]>;
|
|
2252
|
+
/**
|
|
2253
|
+
* (list maxitems:1)
|
|
2254
|
+
*/
|
|
1883
2255
|
workspace: pulumi.Input<inputs.ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspace>;
|
|
1884
2256
|
}
|
|
1885
2257
|
export interface ClusterRkeConfigCloudProviderVsphereCloudProviderDisk {
|
|
2258
|
+
/**
|
|
2259
|
+
* (string)
|
|
2260
|
+
*/
|
|
1886
2261
|
scsiControllerType?: pulumi.Input<string>;
|
|
1887
2262
|
}
|
|
1888
2263
|
export interface ClusterRkeConfigCloudProviderVsphereCloudProviderGlobal {
|
|
2264
|
+
/**
|
|
2265
|
+
* (string)
|
|
2266
|
+
*/
|
|
1889
2267
|
datacenters?: pulumi.Input<string>;
|
|
1890
2268
|
gracefulShutdownTimeout?: pulumi.Input<string>;
|
|
2269
|
+
/**
|
|
2270
|
+
* (bool)
|
|
2271
|
+
*/
|
|
1891
2272
|
insecureFlag?: pulumi.Input<boolean>;
|
|
2273
|
+
/**
|
|
2274
|
+
* Registry password (string)
|
|
2275
|
+
*/
|
|
1892
2276
|
password?: pulumi.Input<string>;
|
|
2277
|
+
/**
|
|
2278
|
+
* Port for node. Default `22` (string)
|
|
2279
|
+
*/
|
|
1893
2280
|
port?: pulumi.Input<string>;
|
|
2281
|
+
/**
|
|
2282
|
+
* (int)
|
|
2283
|
+
*/
|
|
1894
2284
|
soapRoundtripCount?: pulumi.Input<number>;
|
|
2285
|
+
/**
|
|
2286
|
+
* Registry user (string)
|
|
2287
|
+
*/
|
|
1895
2288
|
user?: pulumi.Input<string>;
|
|
1896
2289
|
}
|
|
1897
2290
|
export interface ClusterRkeConfigCloudProviderVsphereCloudProviderNetwork {
|
|
2291
|
+
/**
|
|
2292
|
+
* (string)
|
|
2293
|
+
*/
|
|
1898
2294
|
publicNetwork?: pulumi.Input<string>;
|
|
1899
2295
|
}
|
|
1900
2296
|
export interface ClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenter {
|
|
2297
|
+
/**
|
|
2298
|
+
* (string)
|
|
2299
|
+
*/
|
|
1901
2300
|
datacenters: pulumi.Input<string>;
|
|
1902
2301
|
/**
|
|
1903
2302
|
* The name of the Cluster (string)
|
|
1904
2303
|
*/
|
|
1905
2304
|
name: pulumi.Input<string>;
|
|
2305
|
+
/**
|
|
2306
|
+
* Registry password (string)
|
|
2307
|
+
*/
|
|
1906
2308
|
password: pulumi.Input<string>;
|
|
2309
|
+
/**
|
|
2310
|
+
* Port for node. Default `22` (string)
|
|
2311
|
+
*/
|
|
1907
2312
|
port?: pulumi.Input<string>;
|
|
2313
|
+
/**
|
|
2314
|
+
* (int)
|
|
2315
|
+
*/
|
|
1908
2316
|
soapRoundtripCount?: pulumi.Input<number>;
|
|
2317
|
+
/**
|
|
2318
|
+
* Registry user (string)
|
|
2319
|
+
*/
|
|
1909
2320
|
user: pulumi.Input<string>;
|
|
1910
2321
|
}
|
|
1911
2322
|
export interface ClusterRkeConfigCloudProviderVsphereCloudProviderWorkspace {
|
|
2323
|
+
/**
|
|
2324
|
+
* (string)
|
|
2325
|
+
*/
|
|
1912
2326
|
datacenter: pulumi.Input<string>;
|
|
2327
|
+
/**
|
|
2328
|
+
* (string)
|
|
2329
|
+
*/
|
|
1913
2330
|
defaultDatastore?: pulumi.Input<string>;
|
|
2331
|
+
/**
|
|
2332
|
+
* Folder for S3 service. Available from Rancher v2.2.7 (string)
|
|
2333
|
+
*/
|
|
1914
2334
|
folder: pulumi.Input<string>;
|
|
2335
|
+
/**
|
|
2336
|
+
* (string)
|
|
2337
|
+
*/
|
|
1915
2338
|
resourcepoolPath?: pulumi.Input<string>;
|
|
2339
|
+
/**
|
|
2340
|
+
* (string)
|
|
2341
|
+
*/
|
|
1916
2342
|
server: pulumi.Input<string>;
|
|
1917
2343
|
}
|
|
1918
2344
|
export interface ClusterRkeConfigDns {
|
|
@@ -1920,6 +2346,9 @@ export interface ClusterRkeConfigDns {
|
|
|
1920
2346
|
* Linear Autoscaler Params
|
|
1921
2347
|
*/
|
|
1922
2348
|
linearAutoscalerParams?: pulumi.Input<inputs.ClusterRkeConfigDnsLinearAutoscalerParams>;
|
|
2349
|
+
/**
|
|
2350
|
+
* RKE monitoring node selector (map)
|
|
2351
|
+
*/
|
|
1923
2352
|
nodeSelector?: pulumi.Input<{
|
|
1924
2353
|
[key: string]: any;
|
|
1925
2354
|
}>;
|
|
@@ -1927,10 +2356,19 @@ export interface ClusterRkeConfigDns {
|
|
|
1927
2356
|
* Nodelocal dns
|
|
1928
2357
|
*/
|
|
1929
2358
|
nodelocal?: pulumi.Input<inputs.ClusterRkeConfigDnsNodelocal>;
|
|
2359
|
+
/**
|
|
2360
|
+
* RKE options for network (map)
|
|
2361
|
+
*/
|
|
1930
2362
|
options?: pulumi.Input<{
|
|
1931
2363
|
[key: string]: any;
|
|
1932
2364
|
}>;
|
|
2365
|
+
/**
|
|
2366
|
+
* RKE monitoring provider (string)
|
|
2367
|
+
*/
|
|
1933
2368
|
provider?: pulumi.Input<string>;
|
|
2369
|
+
/**
|
|
2370
|
+
* DNS add-on reverse cidr (list)
|
|
2371
|
+
*/
|
|
1934
2372
|
reverseCidrs?: pulumi.Input<pulumi.Input<string>[]>;
|
|
1935
2373
|
/**
|
|
1936
2374
|
* DNS service tolerations
|
|
@@ -1940,16 +2378,37 @@ export interface ClusterRkeConfigDns {
|
|
|
1940
2378
|
* Update deployment strategy
|
|
1941
2379
|
*/
|
|
1942
2380
|
updateStrategy?: pulumi.Input<inputs.ClusterRkeConfigDnsUpdateStrategy>;
|
|
2381
|
+
/**
|
|
2382
|
+
* DNS add-on upstream nameservers (list)
|
|
2383
|
+
*/
|
|
1943
2384
|
upstreamNameservers?: pulumi.Input<pulumi.Input<string>[]>;
|
|
1944
2385
|
}
|
|
1945
2386
|
export interface ClusterRkeConfigDnsLinearAutoscalerParams {
|
|
2387
|
+
/**
|
|
2388
|
+
* number of replicas per cluster cores (float64)
|
|
2389
|
+
*/
|
|
1946
2390
|
coresPerReplica?: pulumi.Input<number>;
|
|
2391
|
+
/**
|
|
2392
|
+
* maximum number of replicas (int64)
|
|
2393
|
+
*/
|
|
1947
2394
|
max?: pulumi.Input<number>;
|
|
2395
|
+
/**
|
|
2396
|
+
* minimum number of replicas (int64)
|
|
2397
|
+
*/
|
|
1948
2398
|
min?: pulumi.Input<number>;
|
|
2399
|
+
/**
|
|
2400
|
+
* number of replica per cluster nodes (float64)
|
|
2401
|
+
*/
|
|
1949
2402
|
nodesPerReplica?: pulumi.Input<number>;
|
|
2403
|
+
/**
|
|
2404
|
+
* prevent single point of failure
|
|
2405
|
+
*/
|
|
1950
2406
|
preventSinglePointFailure?: pulumi.Input<boolean>;
|
|
1951
2407
|
}
|
|
1952
2408
|
export interface ClusterRkeConfigDnsNodelocal {
|
|
2409
|
+
/**
|
|
2410
|
+
* Nodelocal dns ip address (string)
|
|
2411
|
+
*/
|
|
1953
2412
|
ipAddress?: pulumi.Input<string>;
|
|
1954
2413
|
/**
|
|
1955
2414
|
* Node selector key pair
|
|
@@ -1959,10 +2418,25 @@ export interface ClusterRkeConfigDnsNodelocal {
|
|
|
1959
2418
|
}>;
|
|
1960
2419
|
}
|
|
1961
2420
|
export interface ClusterRkeConfigDnsToleration {
|
|
2421
|
+
/**
|
|
2422
|
+
* The GKE taint effect (string)
|
|
2423
|
+
*/
|
|
1962
2424
|
effect?: pulumi.Input<string>;
|
|
2425
|
+
/**
|
|
2426
|
+
* The GKE taint key (string)
|
|
2427
|
+
*/
|
|
1963
2428
|
key: pulumi.Input<string>;
|
|
2429
|
+
/**
|
|
2430
|
+
* The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
|
|
2431
|
+
*/
|
|
1964
2432
|
operator?: pulumi.Input<string>;
|
|
2433
|
+
/**
|
|
2434
|
+
* The toleration seconds (int)
|
|
2435
|
+
*/
|
|
1965
2436
|
seconds?: pulumi.Input<number>;
|
|
2437
|
+
/**
|
|
2438
|
+
* The GKE taint value (string)
|
|
2439
|
+
*/
|
|
1966
2440
|
value?: pulumi.Input<string>;
|
|
1967
2441
|
}
|
|
1968
2442
|
export interface ClusterRkeConfigDnsUpdateStrategy {
|
|
@@ -1986,20 +2460,47 @@ export interface ClusterRkeConfigDnsUpdateStrategyRollingUpdate {
|
|
|
1986
2460
|
maxUnavailable?: pulumi.Input<number>;
|
|
1987
2461
|
}
|
|
1988
2462
|
export interface ClusterRkeConfigIngress {
|
|
2463
|
+
/**
|
|
2464
|
+
* Enable ingress default backend. Default: `true` (bool)
|
|
2465
|
+
*/
|
|
1989
2466
|
defaultBackend?: pulumi.Input<boolean>;
|
|
2467
|
+
/**
|
|
2468
|
+
* Ingress controller DNS policy. `ClusterFirstWithHostNet`, `ClusterFirst`, `Default`, and `None` are supported. [K8S dns Policy](https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/#pod-s-dns-policy) (string)
|
|
2469
|
+
*/
|
|
1990
2470
|
dnsPolicy?: pulumi.Input<string>;
|
|
2471
|
+
/**
|
|
2472
|
+
* Extra arguments for scheduler service (map)
|
|
2473
|
+
*/
|
|
1991
2474
|
extraArgs?: pulumi.Input<{
|
|
1992
2475
|
[key: string]: any;
|
|
1993
2476
|
}>;
|
|
2477
|
+
/**
|
|
2478
|
+
* HTTP port for RKE Ingress (int)
|
|
2479
|
+
*/
|
|
1994
2480
|
httpPort?: pulumi.Input<number>;
|
|
2481
|
+
/**
|
|
2482
|
+
* HTTPS port for RKE Ingress (int)
|
|
2483
|
+
*/
|
|
1995
2484
|
httpsPort?: pulumi.Input<number>;
|
|
2485
|
+
/**
|
|
2486
|
+
* Network mode for RKE Ingress (string)
|
|
2487
|
+
*/
|
|
1996
2488
|
networkMode?: pulumi.Input<string>;
|
|
2489
|
+
/**
|
|
2490
|
+
* RKE monitoring node selector (map)
|
|
2491
|
+
*/
|
|
1997
2492
|
nodeSelector?: pulumi.Input<{
|
|
1998
2493
|
[key: string]: any;
|
|
1999
2494
|
}>;
|
|
2495
|
+
/**
|
|
2496
|
+
* RKE options for network (map)
|
|
2497
|
+
*/
|
|
2000
2498
|
options?: pulumi.Input<{
|
|
2001
2499
|
[key: string]: any;
|
|
2002
2500
|
}>;
|
|
2501
|
+
/**
|
|
2502
|
+
* RKE monitoring provider (string)
|
|
2503
|
+
*/
|
|
2003
2504
|
provider?: pulumi.Input<string>;
|
|
2004
2505
|
/**
|
|
2005
2506
|
* Ingress add-on tolerations
|
|
@@ -2011,10 +2512,25 @@ export interface ClusterRkeConfigIngress {
|
|
|
2011
2512
|
updateStrategy?: pulumi.Input<inputs.ClusterRkeConfigIngressUpdateStrategy>;
|
|
2012
2513
|
}
|
|
2013
2514
|
export interface ClusterRkeConfigIngressToleration {
|
|
2515
|
+
/**
|
|
2516
|
+
* The GKE taint effect (string)
|
|
2517
|
+
*/
|
|
2014
2518
|
effect?: pulumi.Input<string>;
|
|
2519
|
+
/**
|
|
2520
|
+
* The GKE taint key (string)
|
|
2521
|
+
*/
|
|
2015
2522
|
key: pulumi.Input<string>;
|
|
2523
|
+
/**
|
|
2524
|
+
* The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
|
|
2525
|
+
*/
|
|
2016
2526
|
operator?: pulumi.Input<string>;
|
|
2527
|
+
/**
|
|
2528
|
+
* The toleration seconds (int)
|
|
2529
|
+
*/
|
|
2017
2530
|
seconds?: pulumi.Input<number>;
|
|
2531
|
+
/**
|
|
2532
|
+
* The GKE taint value (string)
|
|
2533
|
+
*/
|
|
2018
2534
|
value?: pulumi.Input<string>;
|
|
2019
2535
|
}
|
|
2020
2536
|
export interface ClusterRkeConfigIngressUpdateStrategy {
|
|
@@ -2034,13 +2550,25 @@ export interface ClusterRkeConfigIngressUpdateStrategyRollingUpdate {
|
|
|
2034
2550
|
maxUnavailable?: pulumi.Input<number>;
|
|
2035
2551
|
}
|
|
2036
2552
|
export interface ClusterRkeConfigMonitoring {
|
|
2553
|
+
/**
|
|
2554
|
+
* RKE monitoring node selector (map)
|
|
2555
|
+
*/
|
|
2037
2556
|
nodeSelector?: pulumi.Input<{
|
|
2038
2557
|
[key: string]: any;
|
|
2039
2558
|
}>;
|
|
2559
|
+
/**
|
|
2560
|
+
* RKE options for network (map)
|
|
2561
|
+
*/
|
|
2040
2562
|
options?: pulumi.Input<{
|
|
2041
2563
|
[key: string]: any;
|
|
2042
2564
|
}>;
|
|
2565
|
+
/**
|
|
2566
|
+
* RKE monitoring provider (string)
|
|
2567
|
+
*/
|
|
2043
2568
|
provider?: pulumi.Input<string>;
|
|
2569
|
+
/**
|
|
2570
|
+
* RKE monitoring replicas (int)
|
|
2571
|
+
*/
|
|
2044
2572
|
replicas?: pulumi.Input<number>;
|
|
2045
2573
|
/**
|
|
2046
2574
|
* Monitoring add-on tolerations
|
|
@@ -2052,10 +2580,25 @@ export interface ClusterRkeConfigMonitoring {
|
|
|
2052
2580
|
updateStrategy?: pulumi.Input<inputs.ClusterRkeConfigMonitoringUpdateStrategy>;
|
|
2053
2581
|
}
|
|
2054
2582
|
export interface ClusterRkeConfigMonitoringToleration {
|
|
2583
|
+
/**
|
|
2584
|
+
* The GKE taint effect (string)
|
|
2585
|
+
*/
|
|
2055
2586
|
effect?: pulumi.Input<string>;
|
|
2587
|
+
/**
|
|
2588
|
+
* The GKE taint key (string)
|
|
2589
|
+
*/
|
|
2056
2590
|
key: pulumi.Input<string>;
|
|
2591
|
+
/**
|
|
2592
|
+
* The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
|
|
2593
|
+
*/
|
|
2057
2594
|
operator?: pulumi.Input<string>;
|
|
2595
|
+
/**
|
|
2596
|
+
* The toleration seconds (int)
|
|
2597
|
+
*/
|
|
2058
2598
|
seconds?: pulumi.Input<number>;
|
|
2599
|
+
/**
|
|
2600
|
+
* The GKE taint value (string)
|
|
2601
|
+
*/
|
|
2059
2602
|
value?: pulumi.Input<string>;
|
|
2060
2603
|
}
|
|
2061
2604
|
export interface ClusterRkeConfigMonitoringUpdateStrategy {
|
|
@@ -2079,120 +2622,402 @@ export interface ClusterRkeConfigMonitoringUpdateStrategyRollingUpdate {
|
|
|
2079
2622
|
maxUnavailable?: pulumi.Input<number>;
|
|
2080
2623
|
}
|
|
2081
2624
|
export interface ClusterRkeConfigNetwork {
|
|
2625
|
+
/**
|
|
2626
|
+
* ACI provider config for RKE network (list maxitems:63)
|
|
2627
|
+
*/
|
|
2082
2628
|
aciNetworkProvider?: pulumi.Input<inputs.ClusterRkeConfigNetworkAciNetworkProvider>;
|
|
2629
|
+
/**
|
|
2630
|
+
* Calico provider config for RKE network (list maxitems:1)
|
|
2631
|
+
*/
|
|
2083
2632
|
calicoNetworkProvider?: pulumi.Input<inputs.ClusterRkeConfigNetworkCalicoNetworkProvider>;
|
|
2633
|
+
/**
|
|
2634
|
+
* Canal provider config for RKE network (list maxitems:1)
|
|
2635
|
+
*/
|
|
2084
2636
|
canalNetworkProvider?: pulumi.Input<inputs.ClusterRkeConfigNetworkCanalNetworkProvider>;
|
|
2637
|
+
/**
|
|
2638
|
+
* Flannel provider config for RKE network (list maxitems:1)
|
|
2639
|
+
*/
|
|
2085
2640
|
flannelNetworkProvider?: pulumi.Input<inputs.ClusterRkeConfigNetworkFlannelNetworkProvider>;
|
|
2641
|
+
/**
|
|
2642
|
+
* Network provider MTU. Default `0` (int)
|
|
2643
|
+
*/
|
|
2086
2644
|
mtu?: pulumi.Input<number>;
|
|
2645
|
+
/**
|
|
2646
|
+
* RKE options for network (map)
|
|
2647
|
+
*/
|
|
2087
2648
|
options?: pulumi.Input<{
|
|
2088
2649
|
[key: string]: any;
|
|
2089
2650
|
}>;
|
|
2651
|
+
/**
|
|
2652
|
+
* Plugin for RKE network. `canal` (default), `flannel`, `calico`, `none` and `weave` are supported. (string)
|
|
2653
|
+
*/
|
|
2090
2654
|
plugin?: pulumi.Input<string>;
|
|
2091
2655
|
/**
|
|
2092
2656
|
* Network add-on tolerations
|
|
2093
2657
|
*/
|
|
2094
2658
|
tolerations?: pulumi.Input<pulumi.Input<inputs.ClusterRkeConfigNetworkToleration>[]>;
|
|
2659
|
+
/**
|
|
2660
|
+
* Weave provider config for RKE network (list maxitems:1)
|
|
2661
|
+
*/
|
|
2095
2662
|
weaveNetworkProvider?: pulumi.Input<inputs.ClusterRkeConfigNetworkWeaveNetworkProvider>;
|
|
2096
2663
|
}
|
|
2097
2664
|
export interface ClusterRkeConfigNetworkAciNetworkProvider {
|
|
2665
|
+
/**
|
|
2666
|
+
* Attachable entity profile (string)
|
|
2667
|
+
*/
|
|
2098
2668
|
aep: pulumi.Input<string>;
|
|
2669
|
+
/**
|
|
2670
|
+
* List of APIC hosts to connect for APIC API (list)
|
|
2671
|
+
*/
|
|
2099
2672
|
apicHosts: pulumi.Input<pulumi.Input<string>[]>;
|
|
2673
|
+
/**
|
|
2674
|
+
* APIC refresh ticker adjust amount (string)
|
|
2675
|
+
*/
|
|
2100
2676
|
apicRefreshTickerAdjust?: pulumi.Input<string>;
|
|
2677
|
+
/**
|
|
2678
|
+
* APIC refresh time in seconds (string)
|
|
2679
|
+
*/
|
|
2101
2680
|
apicRefreshTime?: pulumi.Input<string>;
|
|
2681
|
+
/**
|
|
2682
|
+
* APIC subscription delay amount (string)
|
|
2683
|
+
*/
|
|
2102
2684
|
apicSubscriptionDelay?: pulumi.Input<string>;
|
|
2685
|
+
/**
|
|
2686
|
+
* APIC user certificate (string)
|
|
2687
|
+
*/
|
|
2103
2688
|
apicUserCrt: pulumi.Input<string>;
|
|
2689
|
+
/**
|
|
2690
|
+
* APIC user key (string)
|
|
2691
|
+
*/
|
|
2104
2692
|
apicUserKey: pulumi.Input<string>;
|
|
2693
|
+
/**
|
|
2694
|
+
* APIC user name (string)
|
|
2695
|
+
*/
|
|
2105
2696
|
apicUserName: pulumi.Input<string>;
|
|
2697
|
+
/**
|
|
2698
|
+
* cAPIC cloud (string)
|
|
2699
|
+
*/
|
|
2106
2700
|
capic?: pulumi.Input<string>;
|
|
2701
|
+
/**
|
|
2702
|
+
* Log level for ACI controller (string)
|
|
2703
|
+
*/
|
|
2107
2704
|
controllerLogLevel?: pulumi.Input<string>;
|
|
2705
|
+
/**
|
|
2706
|
+
* Whether to disable periodic SNAT global info sync (string)
|
|
2707
|
+
*/
|
|
2108
2708
|
disablePeriodicSnatGlobalInfoSync?: pulumi.Input<string>;
|
|
2709
|
+
/**
|
|
2710
|
+
* Whether to disable waiting for network (string)
|
|
2711
|
+
*/
|
|
2109
2712
|
disableWaitForNetwork?: pulumi.Input<string>;
|
|
2713
|
+
/**
|
|
2714
|
+
* Whether to enable drop log (string)
|
|
2715
|
+
*/
|
|
2110
2716
|
dropLogEnable?: pulumi.Input<string>;
|
|
2717
|
+
/**
|
|
2718
|
+
* The duration to wait for network (string)
|
|
2719
|
+
*/
|
|
2111
2720
|
durationWaitForNetwork?: pulumi.Input<string>;
|
|
2721
|
+
/**
|
|
2722
|
+
* Whether to enable endpoint slices (string)
|
|
2723
|
+
*/
|
|
2112
2724
|
enableEndpointSlice?: pulumi.Input<string>;
|
|
2725
|
+
/**
|
|
2726
|
+
* Encap type: vxlan or vlan (string)
|
|
2727
|
+
*/
|
|
2113
2728
|
encapType: pulumi.Input<string>;
|
|
2729
|
+
/**
|
|
2730
|
+
* EP registry (string)
|
|
2731
|
+
*/
|
|
2114
2732
|
epRegistry?: pulumi.Input<string>;
|
|
2733
|
+
/**
|
|
2734
|
+
* Subnet to use for dynamic external IPs (string)
|
|
2735
|
+
*/
|
|
2115
2736
|
externDynamic: pulumi.Input<string>;
|
|
2737
|
+
/**
|
|
2738
|
+
* Subnet to use for static external IPs (string)
|
|
2739
|
+
*/
|
|
2116
2740
|
externStatic: pulumi.Input<string>;
|
|
2741
|
+
/**
|
|
2742
|
+
* GBH pod subnet (string)
|
|
2743
|
+
*/
|
|
2117
2744
|
gbpPodSubnet?: pulumi.Input<string>;
|
|
2745
|
+
/**
|
|
2746
|
+
* Log level for ACI host agent (string)
|
|
2747
|
+
*/
|
|
2118
2748
|
hostAgentLogLevel?: pulumi.Input<string>;
|
|
2749
|
+
/**
|
|
2750
|
+
* Image pull policy (string)
|
|
2751
|
+
*/
|
|
2119
2752
|
imagePullPolicy?: pulumi.Input<string>;
|
|
2753
|
+
/**
|
|
2754
|
+
* Image pull policy (string)
|
|
2755
|
+
*/
|
|
2120
2756
|
imagePullSecret?: pulumi.Input<string>;
|
|
2757
|
+
/**
|
|
2758
|
+
* The VLAN used by ACI infra (string)
|
|
2759
|
+
*/
|
|
2121
2760
|
infraVlan?: pulumi.Input<string>;
|
|
2761
|
+
/**
|
|
2762
|
+
* Whether to install Istio (string)
|
|
2763
|
+
*/
|
|
2122
2764
|
installIstio?: pulumi.Input<string>;
|
|
2765
|
+
/**
|
|
2766
|
+
* Istio profile name (string)
|
|
2767
|
+
*/
|
|
2123
2768
|
istioProfile?: pulumi.Input<string>;
|
|
2769
|
+
/**
|
|
2770
|
+
* List of Kafka broker hosts (list)
|
|
2771
|
+
*/
|
|
2124
2772
|
kafkaBrokers?: pulumi.Input<pulumi.Input<string>[]>;
|
|
2773
|
+
/**
|
|
2774
|
+
* Kafka client certificate (string)
|
|
2775
|
+
*/
|
|
2125
2776
|
kafkaClientCrt?: pulumi.Input<string>;
|
|
2777
|
+
/**
|
|
2778
|
+
* Kafka client key (string)
|
|
2779
|
+
*/
|
|
2126
2780
|
kafkaClientKey?: pulumi.Input<string>;
|
|
2781
|
+
/**
|
|
2782
|
+
* The VLAN used by the physdom for nodes (string)
|
|
2783
|
+
*/
|
|
2127
2784
|
kubeApiVlan: pulumi.Input<string>;
|
|
2785
|
+
/**
|
|
2786
|
+
* L3out (string)
|
|
2787
|
+
*/
|
|
2128
2788
|
l3out: pulumi.Input<string>;
|
|
2789
|
+
/**
|
|
2790
|
+
* L3out external networks (list)
|
|
2791
|
+
*/
|
|
2129
2792
|
l3outExternalNetworks: pulumi.Input<pulumi.Input<string>[]>;
|
|
2793
|
+
/**
|
|
2794
|
+
* Max nodes in service graph (string)
|
|
2795
|
+
*/
|
|
2130
2796
|
maxNodesSvcGraph?: pulumi.Input<string>;
|
|
2797
|
+
/**
|
|
2798
|
+
* End of mcast range (string)
|
|
2799
|
+
*/
|
|
2131
2800
|
mcastRangeEnd: pulumi.Input<string>;
|
|
2801
|
+
/**
|
|
2802
|
+
* Start of mcast range (string)
|
|
2803
|
+
*/
|
|
2132
2804
|
mcastRangeStart: pulumi.Input<string>;
|
|
2805
|
+
/**
|
|
2806
|
+
* MTU head room amount (string)
|
|
2807
|
+
*/
|
|
2133
2808
|
mtuHeadRoom?: pulumi.Input<string>;
|
|
2809
|
+
/**
|
|
2810
|
+
* Whether to disable Multus (string)
|
|
2811
|
+
*/
|
|
2134
2812
|
multusDisable?: pulumi.Input<string>;
|
|
2813
|
+
/**
|
|
2814
|
+
* Whether to use priority class (string)
|
|
2815
|
+
*/
|
|
2135
2816
|
noPriorityClass?: pulumi.Input<string>;
|
|
2817
|
+
/**
|
|
2818
|
+
* Whether to enable node pod interface (string)
|
|
2819
|
+
*/
|
|
2136
2820
|
nodePodIfEnable?: pulumi.Input<string>;
|
|
2821
|
+
/**
|
|
2822
|
+
* Subnet to use for nodes (string)
|
|
2823
|
+
*/
|
|
2137
2824
|
nodeSubnet: pulumi.Input<string>;
|
|
2825
|
+
/**
|
|
2826
|
+
* Subnet to use for service graph (string)
|
|
2827
|
+
*/
|
|
2138
2828
|
nodeSvcSubnet: pulumi.Input<string>;
|
|
2829
|
+
/**
|
|
2830
|
+
* Whether to use client SSL for Opflex (string)
|
|
2831
|
+
*/
|
|
2139
2832
|
opflexClientSsl?: pulumi.Input<string>;
|
|
2833
|
+
/**
|
|
2834
|
+
* Opflex device delete timeout (string)
|
|
2835
|
+
*/
|
|
2140
2836
|
opflexDeviceDeleteTimeout?: pulumi.Input<string>;
|
|
2837
|
+
/**
|
|
2838
|
+
* Log level for ACI opflex (string)
|
|
2839
|
+
*/
|
|
2141
2840
|
opflexLogLevel?: pulumi.Input<string>;
|
|
2841
|
+
/**
|
|
2842
|
+
* Opflex mode (string)
|
|
2843
|
+
*/
|
|
2142
2844
|
opflexMode?: pulumi.Input<string>;
|
|
2845
|
+
/**
|
|
2846
|
+
* Opflex server port (string)
|
|
2847
|
+
*/
|
|
2143
2848
|
opflexServerPort?: pulumi.Input<string>;
|
|
2849
|
+
/**
|
|
2850
|
+
* Overlay VRF name (string)
|
|
2851
|
+
*/
|
|
2144
2852
|
overlayVrfName?: pulumi.Input<string>;
|
|
2853
|
+
/**
|
|
2854
|
+
* OVS memory limit (string)
|
|
2855
|
+
*/
|
|
2145
2856
|
ovsMemoryLimit?: pulumi.Input<string>;
|
|
2857
|
+
/**
|
|
2858
|
+
* Policy-based routing tracking non snat (string)
|
|
2859
|
+
*/
|
|
2146
2860
|
pbrTrackingNonSnat?: pulumi.Input<string>;
|
|
2861
|
+
/**
|
|
2862
|
+
* Pod subnet chunk size (string)
|
|
2863
|
+
*/
|
|
2147
2864
|
podSubnetChunkSize?: pulumi.Input<string>;
|
|
2865
|
+
/**
|
|
2866
|
+
* Whether to run GBP container (string)
|
|
2867
|
+
*/
|
|
2148
2868
|
runGbpContainer?: pulumi.Input<string>;
|
|
2869
|
+
/**
|
|
2870
|
+
* Whether to run Opflex server container (string)
|
|
2871
|
+
*/
|
|
2149
2872
|
runOpflexServerContainer?: pulumi.Input<string>;
|
|
2873
|
+
/**
|
|
2874
|
+
* Service monitor interval (string)
|
|
2875
|
+
*/
|
|
2150
2876
|
serviceMonitorInterval?: pulumi.Input<string>;
|
|
2877
|
+
/**
|
|
2878
|
+
* The VLAN used by LoadBalancer services (string)
|
|
2879
|
+
*/
|
|
2151
2880
|
serviceVlan: pulumi.Input<string>;
|
|
2881
|
+
/**
|
|
2882
|
+
* Snat contract scope (string)
|
|
2883
|
+
*/
|
|
2152
2884
|
snatContractScope?: pulumi.Input<string>;
|
|
2885
|
+
/**
|
|
2886
|
+
* Snat namespace (string)
|
|
2887
|
+
*/
|
|
2153
2888
|
snatNamespace?: pulumi.Input<string>;
|
|
2889
|
+
/**
|
|
2890
|
+
* End of snat port range (string)
|
|
2891
|
+
*/
|
|
2154
2892
|
snatPortRangeEnd?: pulumi.Input<string>;
|
|
2893
|
+
/**
|
|
2894
|
+
* End of snat port range (string)
|
|
2895
|
+
*/
|
|
2155
2896
|
snatPortRangeStart?: pulumi.Input<string>;
|
|
2897
|
+
/**
|
|
2898
|
+
* Snat ports per node (string)
|
|
2899
|
+
*/
|
|
2156
2900
|
snatPortsPerNode?: pulumi.Input<string>;
|
|
2901
|
+
/**
|
|
2902
|
+
* Whether to enable SR-IOV (string)
|
|
2903
|
+
*/
|
|
2157
2904
|
sriovEnable?: pulumi.Input<string>;
|
|
2905
|
+
/**
|
|
2906
|
+
* Subnet domain name (string)
|
|
2907
|
+
*/
|
|
2158
2908
|
subnetDomainName?: pulumi.Input<string>;
|
|
2909
|
+
/**
|
|
2910
|
+
* ACI system ID (string)
|
|
2911
|
+
*/
|
|
2159
2912
|
systemId: pulumi.Input<string>;
|
|
2913
|
+
/**
|
|
2914
|
+
* ACI tenant (string)
|
|
2915
|
+
*/
|
|
2160
2916
|
tenant?: pulumi.Input<string>;
|
|
2161
2917
|
token: pulumi.Input<string>;
|
|
2918
|
+
/**
|
|
2919
|
+
* Whether to use ACI anywhere CRD (string)
|
|
2920
|
+
*/
|
|
2162
2921
|
useAciAnywhereCrd?: pulumi.Input<string>;
|
|
2922
|
+
/**
|
|
2923
|
+
* Whether to use ACI CNI priority class (string)
|
|
2924
|
+
*/
|
|
2163
2925
|
useAciCniPriorityClass?: pulumi.Input<string>;
|
|
2926
|
+
/**
|
|
2927
|
+
* Whether to use cluster role (string)
|
|
2928
|
+
*/
|
|
2164
2929
|
useClusterRole?: pulumi.Input<string>;
|
|
2930
|
+
/**
|
|
2931
|
+
* Whether to use host netns volume (string)
|
|
2932
|
+
*/
|
|
2165
2933
|
useHostNetnsVolume?: pulumi.Input<string>;
|
|
2934
|
+
/**
|
|
2935
|
+
* Whether use Opflex server volume (string)
|
|
2936
|
+
*/
|
|
2166
2937
|
useOpflexServerVolume?: pulumi.Input<string>;
|
|
2938
|
+
/**
|
|
2939
|
+
* Whether ACI containers should run as privileged (string)
|
|
2940
|
+
*/
|
|
2167
2941
|
usePrivilegedContainer?: pulumi.Input<string>;
|
|
2942
|
+
/**
|
|
2943
|
+
* VMM controller configuration (string)
|
|
2944
|
+
*/
|
|
2168
2945
|
vmmController?: pulumi.Input<string>;
|
|
2946
|
+
/**
|
|
2947
|
+
* VMM domain configuration (string)
|
|
2948
|
+
*/
|
|
2169
2949
|
vmmDomain?: pulumi.Input<string>;
|
|
2950
|
+
/**
|
|
2951
|
+
* VRF name (string)
|
|
2952
|
+
*/
|
|
2170
2953
|
vrfName: pulumi.Input<string>;
|
|
2954
|
+
/**
|
|
2955
|
+
* VRF tenant (string)
|
|
2956
|
+
*/
|
|
2171
2957
|
vrfTenant: pulumi.Input<string>;
|
|
2172
2958
|
}
|
|
2173
2959
|
export interface ClusterRkeConfigNetworkCalicoNetworkProvider {
|
|
2960
|
+
/**
|
|
2961
|
+
* RKE options for Calico network provider (string)
|
|
2962
|
+
*/
|
|
2174
2963
|
cloudProvider?: pulumi.Input<string>;
|
|
2175
2964
|
}
|
|
2176
2965
|
export interface ClusterRkeConfigNetworkCanalNetworkProvider {
|
|
2966
|
+
/**
|
|
2967
|
+
* Iface config Flannel network provider (string)
|
|
2968
|
+
*/
|
|
2177
2969
|
iface?: pulumi.Input<string>;
|
|
2178
2970
|
}
|
|
2179
2971
|
export interface ClusterRkeConfigNetworkFlannelNetworkProvider {
|
|
2972
|
+
/**
|
|
2973
|
+
* Iface config Flannel network provider (string)
|
|
2974
|
+
*/
|
|
2180
2975
|
iface?: pulumi.Input<string>;
|
|
2181
2976
|
}
|
|
2182
2977
|
export interface ClusterRkeConfigNetworkToleration {
|
|
2978
|
+
/**
|
|
2979
|
+
* The GKE taint effect (string)
|
|
2980
|
+
*/
|
|
2183
2981
|
effect?: pulumi.Input<string>;
|
|
2982
|
+
/**
|
|
2983
|
+
* The GKE taint key (string)
|
|
2984
|
+
*/
|
|
2184
2985
|
key: pulumi.Input<string>;
|
|
2986
|
+
/**
|
|
2987
|
+
* The toleration operator. `Equal`, and `Exists` are supported. Default: `Equal` (string)
|
|
2988
|
+
*/
|
|
2185
2989
|
operator?: pulumi.Input<string>;
|
|
2990
|
+
/**
|
|
2991
|
+
* The toleration seconds (int)
|
|
2992
|
+
*/
|
|
2186
2993
|
seconds?: pulumi.Input<number>;
|
|
2994
|
+
/**
|
|
2995
|
+
* The GKE taint value (string)
|
|
2996
|
+
*/
|
|
2187
2997
|
value?: pulumi.Input<string>;
|
|
2188
2998
|
}
|
|
2189
2999
|
export interface ClusterRkeConfigNetworkWeaveNetworkProvider {
|
|
3000
|
+
/**
|
|
3001
|
+
* Registry password (string)
|
|
3002
|
+
*/
|
|
2190
3003
|
password: pulumi.Input<string>;
|
|
2191
3004
|
}
|
|
2192
3005
|
export interface ClusterRkeConfigNode {
|
|
3006
|
+
/**
|
|
3007
|
+
* Address ip for node (string)
|
|
3008
|
+
*/
|
|
2193
3009
|
address: pulumi.Input<string>;
|
|
3010
|
+
/**
|
|
3011
|
+
* Docker socket for node (string)
|
|
3012
|
+
*/
|
|
2194
3013
|
dockerSocket?: pulumi.Input<string>;
|
|
3014
|
+
/**
|
|
3015
|
+
* Hostname override for node (string)
|
|
3016
|
+
*/
|
|
2195
3017
|
hostnameOverride?: pulumi.Input<string>;
|
|
3018
|
+
/**
|
|
3019
|
+
* Internal ip for node (string)
|
|
3020
|
+
*/
|
|
2196
3021
|
internalAddress?: pulumi.Input<string>;
|
|
2197
3022
|
/**
|
|
2198
3023
|
* Labels for the Cluster (map)
|
|
@@ -2200,12 +3025,33 @@ export interface ClusterRkeConfigNode {
|
|
|
2200
3025
|
labels?: pulumi.Input<{
|
|
2201
3026
|
[key: string]: any;
|
|
2202
3027
|
}>;
|
|
3028
|
+
/**
|
|
3029
|
+
* Id for the node (string)
|
|
3030
|
+
*/
|
|
2203
3031
|
nodeId?: pulumi.Input<string>;
|
|
3032
|
+
/**
|
|
3033
|
+
* Port for node. Default `22` (string)
|
|
3034
|
+
*/
|
|
2204
3035
|
port?: pulumi.Input<string>;
|
|
3036
|
+
/**
|
|
3037
|
+
* Roles for the node. `controlplane`, `etcd` and `worker` are supported. (list)
|
|
3038
|
+
*/
|
|
2205
3039
|
roles: pulumi.Input<pulumi.Input<string>[]>;
|
|
3040
|
+
/**
|
|
3041
|
+
* Use ssh agent auth. Default `false` (bool)
|
|
3042
|
+
*/
|
|
2206
3043
|
sshAgentAuth?: pulumi.Input<boolean>;
|
|
3044
|
+
/**
|
|
3045
|
+
* Node SSH private key (string)
|
|
3046
|
+
*/
|
|
2207
3047
|
sshKey?: pulumi.Input<string>;
|
|
3048
|
+
/**
|
|
3049
|
+
* Node SSH private key path (string)
|
|
3050
|
+
*/
|
|
2208
3051
|
sshKeyPath?: pulumi.Input<string>;
|
|
3052
|
+
/**
|
|
3053
|
+
* Registry user (string)
|
|
3054
|
+
*/
|
|
2209
3055
|
user: pulumi.Input<string>;
|
|
2210
3056
|
}
|
|
2211
3057
|
export interface ClusterRkeConfigPrivateRegistry {
|
|
@@ -2213,61 +3059,181 @@ export interface ClusterRkeConfigPrivateRegistry {
|
|
|
2213
3059
|
* ECR credential plugin config
|
|
2214
3060
|
*/
|
|
2215
3061
|
ecrCredentialPlugin?: pulumi.Input<inputs.ClusterRkeConfigPrivateRegistryEcrCredentialPlugin>;
|
|
3062
|
+
/**
|
|
3063
|
+
* Set as default registry. Default `false` (bool)
|
|
3064
|
+
*/
|
|
2216
3065
|
isDefault?: pulumi.Input<boolean>;
|
|
3066
|
+
/**
|
|
3067
|
+
* Registry password (string)
|
|
3068
|
+
*/
|
|
2217
3069
|
password?: pulumi.Input<string>;
|
|
3070
|
+
/**
|
|
3071
|
+
* Registry URL (string)
|
|
3072
|
+
*/
|
|
2218
3073
|
url: pulumi.Input<string>;
|
|
3074
|
+
/**
|
|
3075
|
+
* Registry user (string)
|
|
3076
|
+
*/
|
|
2219
3077
|
user?: pulumi.Input<string>;
|
|
2220
3078
|
}
|
|
2221
3079
|
export interface ClusterRkeConfigPrivateRegistryEcrCredentialPlugin {
|
|
3080
|
+
/**
|
|
3081
|
+
* AWS access key ID (string)
|
|
3082
|
+
*/
|
|
2222
3083
|
awsAccessKeyId?: pulumi.Input<string>;
|
|
3084
|
+
/**
|
|
3085
|
+
* AWS secret access key (string)
|
|
3086
|
+
*/
|
|
2223
3087
|
awsSecretAccessKey?: pulumi.Input<string>;
|
|
3088
|
+
/**
|
|
3089
|
+
* AWS session token (string)
|
|
3090
|
+
*/
|
|
2224
3091
|
awsSessionToken?: pulumi.Input<string>;
|
|
2225
3092
|
}
|
|
2226
3093
|
export interface ClusterRkeConfigServices {
|
|
3094
|
+
/**
|
|
3095
|
+
* Etcd options for RKE services (list maxitems:1)
|
|
3096
|
+
*/
|
|
2227
3097
|
etcd?: pulumi.Input<inputs.ClusterRkeConfigServicesEtcd>;
|
|
3098
|
+
/**
|
|
3099
|
+
* Kube API options for RKE services (list maxitems:1)
|
|
3100
|
+
*/
|
|
2228
3101
|
kubeApi?: pulumi.Input<inputs.ClusterRkeConfigServicesKubeApi>;
|
|
3102
|
+
/**
|
|
3103
|
+
* Kube Controller options for RKE services (list maxitems:1)
|
|
3104
|
+
*/
|
|
2229
3105
|
kubeController?: pulumi.Input<inputs.ClusterRkeConfigServicesKubeController>;
|
|
3106
|
+
/**
|
|
3107
|
+
* Kubelet options for RKE services (list maxitems:1)
|
|
3108
|
+
*/
|
|
2230
3109
|
kubelet?: pulumi.Input<inputs.ClusterRkeConfigServicesKubelet>;
|
|
3110
|
+
/**
|
|
3111
|
+
* Kubeproxy options for RKE services (list maxitems:1)
|
|
3112
|
+
*/
|
|
2231
3113
|
kubeproxy?: pulumi.Input<inputs.ClusterRkeConfigServicesKubeproxy>;
|
|
3114
|
+
/**
|
|
3115
|
+
* Scheduler options for RKE services (list maxitems:1)
|
|
3116
|
+
*/
|
|
2232
3117
|
scheduler?: pulumi.Input<inputs.ClusterRkeConfigServicesScheduler>;
|
|
2233
3118
|
}
|
|
2234
3119
|
export interface ClusterRkeConfigServicesEtcd {
|
|
3120
|
+
/**
|
|
3121
|
+
* Backup options for etcd service. For Rancher v2.2.x (list maxitems:1)
|
|
3122
|
+
*/
|
|
2235
3123
|
backupConfig?: pulumi.Input<inputs.ClusterRkeConfigServicesEtcdBackupConfig>;
|
|
2236
3124
|
/**
|
|
2237
3125
|
* (Computed/Sensitive) K8s cluster ca cert (string)
|
|
2238
3126
|
*/
|
|
2239
3127
|
caCert?: pulumi.Input<string>;
|
|
3128
|
+
/**
|
|
3129
|
+
* TLS certificate for etcd service (string)
|
|
3130
|
+
*/
|
|
2240
3131
|
cert?: pulumi.Input<string>;
|
|
3132
|
+
/**
|
|
3133
|
+
* Creation option for etcd service (string)
|
|
3134
|
+
*/
|
|
2241
3135
|
creation?: pulumi.Input<string>;
|
|
3136
|
+
/**
|
|
3137
|
+
* External urls for etcd service (list)
|
|
3138
|
+
*/
|
|
2242
3139
|
externalUrls?: pulumi.Input<pulumi.Input<string>[]>;
|
|
3140
|
+
/**
|
|
3141
|
+
* Extra arguments for scheduler service (map)
|
|
3142
|
+
*/
|
|
2243
3143
|
extraArgs?: pulumi.Input<{
|
|
2244
3144
|
[key: string]: any;
|
|
2245
3145
|
}>;
|
|
3146
|
+
/**
|
|
3147
|
+
* Extra binds for scheduler service (list)
|
|
3148
|
+
*/
|
|
2246
3149
|
extraBinds?: pulumi.Input<pulumi.Input<string>[]>;
|
|
3150
|
+
/**
|
|
3151
|
+
* Extra environment for scheduler service (list)
|
|
3152
|
+
*/
|
|
2247
3153
|
extraEnvs?: pulumi.Input<pulumi.Input<string>[]>;
|
|
3154
|
+
/**
|
|
3155
|
+
* Etcd service GID. Default: `0`. For Rancher v2.3.x and above (int)
|
|
3156
|
+
*/
|
|
2248
3157
|
gid?: pulumi.Input<number>;
|
|
3158
|
+
/**
|
|
3159
|
+
* Docker image for scheduler service (string)
|
|
3160
|
+
*/
|
|
2249
3161
|
image?: pulumi.Input<string>;
|
|
3162
|
+
/**
|
|
3163
|
+
* The GKE taint key (string)
|
|
3164
|
+
*/
|
|
2250
3165
|
key?: pulumi.Input<string>;
|
|
3166
|
+
/**
|
|
3167
|
+
* (Optional) Audit log path. Default: `/var/log/kube-audit/audit-log.json` (string)
|
|
3168
|
+
*/
|
|
2251
3169
|
path?: pulumi.Input<string>;
|
|
3170
|
+
/**
|
|
3171
|
+
* Retention for etcd backup. Default `6` (int)
|
|
3172
|
+
*/
|
|
2252
3173
|
retention?: pulumi.Input<string>;
|
|
3174
|
+
/**
|
|
3175
|
+
* Snapshot option for etcd service (bool)
|
|
3176
|
+
*/
|
|
2253
3177
|
snapshot?: pulumi.Input<boolean>;
|
|
3178
|
+
/**
|
|
3179
|
+
* Etcd service UID. Default: `0`. For Rancher v2.3.x and above (int)
|
|
3180
|
+
*/
|
|
2254
3181
|
uid?: pulumi.Input<number>;
|
|
2255
3182
|
}
|
|
2256
3183
|
export interface ClusterRkeConfigServicesEtcdBackupConfig {
|
|
3184
|
+
/**
|
|
3185
|
+
* Enable the authorized cluster endpoint. Default `true` (bool)
|
|
3186
|
+
*/
|
|
2257
3187
|
enabled?: pulumi.Input<boolean>;
|
|
3188
|
+
/**
|
|
3189
|
+
* Interval hours for etcd backup. Default `12` (int)
|
|
3190
|
+
*/
|
|
2258
3191
|
intervalHours?: pulumi.Input<number>;
|
|
3192
|
+
/**
|
|
3193
|
+
* Retention for etcd backup. Default `6` (int)
|
|
3194
|
+
*/
|
|
2259
3195
|
retention?: pulumi.Input<number>;
|
|
3196
|
+
/**
|
|
3197
|
+
* S3 config options for etcd backup (list maxitems:1)
|
|
3198
|
+
*/
|
|
2260
3199
|
s3BackupConfig?: pulumi.Input<inputs.ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfig>;
|
|
3200
|
+
/**
|
|
3201
|
+
* Safe timestamp for etcd backup. Default: `false` (bool)
|
|
3202
|
+
*/
|
|
2261
3203
|
safeTimestamp?: pulumi.Input<boolean>;
|
|
3204
|
+
/**
|
|
3205
|
+
* RKE node drain timeout. Default: `60` (int)
|
|
3206
|
+
*/
|
|
2262
3207
|
timeout?: pulumi.Input<number>;
|
|
2263
3208
|
}
|
|
2264
3209
|
export interface ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfig {
|
|
3210
|
+
/**
|
|
3211
|
+
* The AWS Client ID to use (string)
|
|
3212
|
+
*/
|
|
2265
3213
|
accessKey?: pulumi.Input<string>;
|
|
3214
|
+
/**
|
|
3215
|
+
* Bucket name for S3 service (string)
|
|
3216
|
+
*/
|
|
2266
3217
|
bucketName: pulumi.Input<string>;
|
|
3218
|
+
/**
|
|
3219
|
+
* Base64 encoded custom CA for S3 service. Use filebase64(<FILE>) for encoding file. Available from Rancher v2.2.5 (string)
|
|
3220
|
+
*/
|
|
2267
3221
|
customCa?: pulumi.Input<string>;
|
|
3222
|
+
/**
|
|
3223
|
+
* Endpoint for S3 service (string)
|
|
3224
|
+
*/
|
|
2268
3225
|
endpoint: pulumi.Input<string>;
|
|
3226
|
+
/**
|
|
3227
|
+
* Folder for S3 service. Available from Rancher v2.2.7 (string)
|
|
3228
|
+
*/
|
|
2269
3229
|
folder?: pulumi.Input<string>;
|
|
3230
|
+
/**
|
|
3231
|
+
* The availability domain within the region to host the cluster. See [here](https://docs.cloud.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm) for a list of region names. (string)
|
|
3232
|
+
*/
|
|
2270
3233
|
region?: pulumi.Input<string>;
|
|
3234
|
+
/**
|
|
3235
|
+
* The AWS Client Secret associated with the Client ID (string)
|
|
3236
|
+
*/
|
|
2271
3237
|
secretKey?: pulumi.Input<string>;
|
|
2272
3238
|
}
|
|
2273
3239
|
export interface ClusterRkeConfigServicesKubeApi {
|
|
@@ -2275,18 +3241,51 @@ export interface ClusterRkeConfigServicesKubeApi {
|
|
|
2275
3241
|
* Cluster admission configuration
|
|
2276
3242
|
*/
|
|
2277
3243
|
admissionConfiguration?: pulumi.Input<inputs.ClusterRkeConfigServicesKubeApiAdmissionConfiguration>;
|
|
3244
|
+
/**
|
|
3245
|
+
* Enable [AlwaysPullImages](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#alwayspullimages) Admission controller plugin. [Rancher docs](https://rancher.com/docs/rke/latest/en/config-options/services/#kubernetes-api-server-options) Default: `false` (bool)
|
|
3246
|
+
*/
|
|
2278
3247
|
alwaysPullImages?: pulumi.Input<boolean>;
|
|
3248
|
+
/**
|
|
3249
|
+
* K8s audit log configuration. (list maxitems: 1)
|
|
3250
|
+
*/
|
|
2279
3251
|
auditLog?: pulumi.Input<inputs.ClusterRkeConfigServicesKubeApiAuditLog>;
|
|
3252
|
+
/**
|
|
3253
|
+
* K8s event rate limit configuration. (list maxitems: 1)
|
|
3254
|
+
*/
|
|
2280
3255
|
eventRateLimit?: pulumi.Input<inputs.ClusterRkeConfigServicesKubeApiEventRateLimit>;
|
|
3256
|
+
/**
|
|
3257
|
+
* Extra arguments for scheduler service (map)
|
|
3258
|
+
*/
|
|
2281
3259
|
extraArgs?: pulumi.Input<{
|
|
2282
3260
|
[key: string]: any;
|
|
2283
3261
|
}>;
|
|
3262
|
+
/**
|
|
3263
|
+
* Extra binds for scheduler service (list)
|
|
3264
|
+
*/
|
|
2284
3265
|
extraBinds?: pulumi.Input<pulumi.Input<string>[]>;
|
|
3266
|
+
/**
|
|
3267
|
+
* Extra environment for scheduler service (list)
|
|
3268
|
+
*/
|
|
2285
3269
|
extraEnvs?: pulumi.Input<pulumi.Input<string>[]>;
|
|
3270
|
+
/**
|
|
3271
|
+
* Docker image for scheduler service (string)
|
|
3272
|
+
*/
|
|
2286
3273
|
image?: pulumi.Input<string>;
|
|
3274
|
+
/**
|
|
3275
|
+
* Pod Security Policy option for kube API service. Default `false` (bool)
|
|
3276
|
+
*/
|
|
2287
3277
|
podSecurityPolicy?: pulumi.Input<boolean>;
|
|
3278
|
+
/**
|
|
3279
|
+
* [Encrypt k8s secret data configration](https://rancher.com/docs/rke/latest/en/config-options/secrets-encryption/). (list maxitem: 1)
|
|
3280
|
+
*/
|
|
2288
3281
|
secretsEncryptionConfig?: pulumi.Input<inputs.ClusterRkeConfigServicesKubeApiSecretsEncryptionConfig>;
|
|
3282
|
+
/**
|
|
3283
|
+
* Service Cluster ip Range option for kube controller service (string)
|
|
3284
|
+
*/
|
|
2289
3285
|
serviceClusterIpRange?: pulumi.Input<string>;
|
|
3286
|
+
/**
|
|
3287
|
+
* Service Node Port Range option for kube API service (string)
|
|
3288
|
+
*/
|
|
2290
3289
|
serviceNodePortRange?: pulumi.Input<string>;
|
|
2291
3290
|
}
|
|
2292
3291
|
export interface ClusterRkeConfigServicesKubeApiAdmissionConfiguration {
|
|
@@ -2318,75 +3317,258 @@ export interface ClusterRkeConfigServicesKubeApiAdmissionConfigurationPlugin {
|
|
|
2318
3317
|
path?: pulumi.Input<string>;
|
|
2319
3318
|
}
|
|
2320
3319
|
export interface ClusterRkeConfigServicesKubeApiAuditLog {
|
|
3320
|
+
/**
|
|
3321
|
+
* Event rate limit configuration yaml encoded definition. `apiVersion` and `kind: Configuration"` fields are required in the yaml. [More info](https://rancher.com/docs/rke/latest/en/config-options/rate-limiting/) (string) Ex:
|
|
3322
|
+
*
|
|
3323
|
+
* ```
|
|
3324
|
+
* configuration = <<EOF
|
|
3325
|
+
* apiVersion: eventratelimit.admission.k8s.io/v1alpha1
|
|
3326
|
+
* kind: Configuration
|
|
3327
|
+
* limits:
|
|
3328
|
+
* - type: Server
|
|
3329
|
+
* burst: 35000
|
|
3330
|
+
* qps: 6000
|
|
3331
|
+
* EOF
|
|
3332
|
+
* ```
|
|
3333
|
+
*/
|
|
2321
3334
|
configuration?: pulumi.Input<inputs.ClusterRkeConfigServicesKubeApiAuditLogConfiguration>;
|
|
3335
|
+
/**
|
|
3336
|
+
* Enable the authorized cluster endpoint. Default `true` (bool)
|
|
3337
|
+
*/
|
|
2322
3338
|
enabled?: pulumi.Input<boolean>;
|
|
2323
3339
|
}
|
|
2324
3340
|
export interface ClusterRkeConfigServicesKubeApiAuditLogConfiguration {
|
|
3341
|
+
/**
|
|
3342
|
+
* Audit log format. Default: 'json' (string)
|
|
3343
|
+
*/
|
|
2325
3344
|
format?: pulumi.Input<string>;
|
|
3345
|
+
/**
|
|
3346
|
+
* Audit log max age. Default: `30` (int)
|
|
3347
|
+
*/
|
|
2326
3348
|
maxAge?: pulumi.Input<number>;
|
|
3349
|
+
/**
|
|
3350
|
+
* Audit log max backup. Default: `10` (int)
|
|
3351
|
+
*/
|
|
2327
3352
|
maxBackup?: pulumi.Input<number>;
|
|
3353
|
+
/**
|
|
3354
|
+
* The EKS node group maximum size. Default `2` (int)
|
|
3355
|
+
*/
|
|
2328
3356
|
maxSize?: pulumi.Input<number>;
|
|
3357
|
+
/**
|
|
3358
|
+
* (Optional) Audit log path. Default: `/var/log/kube-audit/audit-log.json` (string)
|
|
3359
|
+
*/
|
|
2329
3360
|
path?: pulumi.Input<string>;
|
|
3361
|
+
/**
|
|
3362
|
+
* Audit policy yaml encoded definition. `apiVersion` and `kind: Policy\nrules:"` fields are required in the yaml. [More info](https://rancher.com/docs/rke/latest/en/config-options/audit-log/) (string) Ex:
|
|
3363
|
+
*
|
|
3364
|
+
* ```
|
|
3365
|
+
* policy = <<EOF
|
|
3366
|
+
* apiVersion: audit.k8s.io/v1
|
|
3367
|
+
* kind: Policy
|
|
3368
|
+
* rules:
|
|
3369
|
+
* - level: RequestResponse
|
|
3370
|
+
* resources:
|
|
3371
|
+
* - resources:
|
|
3372
|
+
* - pods
|
|
3373
|
+
* EOF
|
|
3374
|
+
* ```
|
|
3375
|
+
*/
|
|
2330
3376
|
policy?: pulumi.Input<string>;
|
|
2331
3377
|
}
|
|
2332
3378
|
export interface ClusterRkeConfigServicesKubeApiEventRateLimit {
|
|
3379
|
+
/**
|
|
3380
|
+
* Event rate limit configuration yaml encoded definition. `apiVersion` and `kind: Configuration"` fields are required in the yaml. [More info](https://rancher.com/docs/rke/latest/en/config-options/rate-limiting/) (string) Ex:
|
|
3381
|
+
*
|
|
3382
|
+
* ```
|
|
3383
|
+
* configuration = <<EOF
|
|
3384
|
+
* apiVersion: eventratelimit.admission.k8s.io/v1alpha1
|
|
3385
|
+
* kind: Configuration
|
|
3386
|
+
* limits:
|
|
3387
|
+
* - type: Server
|
|
3388
|
+
* burst: 35000
|
|
3389
|
+
* qps: 6000
|
|
3390
|
+
* EOF
|
|
3391
|
+
* ```
|
|
3392
|
+
*/
|
|
2333
3393
|
configuration?: pulumi.Input<string>;
|
|
3394
|
+
/**
|
|
3395
|
+
* Enable the authorized cluster endpoint. Default `true` (bool)
|
|
3396
|
+
*/
|
|
2334
3397
|
enabled?: pulumi.Input<boolean>;
|
|
2335
3398
|
}
|
|
2336
3399
|
export interface ClusterRkeConfigServicesKubeApiSecretsEncryptionConfig {
|
|
3400
|
+
/**
|
|
3401
|
+
* Secrets encryption yaml encoded custom configuration. `"apiVersion"` and `"kind":"EncryptionConfiguration"` fields are required in the yaml. [More info](https://rancher.com/docs/rke/latest/en/config-options/secrets-encryption/) (string) Ex:
|
|
3402
|
+
*
|
|
3403
|
+
* ```
|
|
3404
|
+
* custom_config = <<EOF
|
|
3405
|
+
* apiVersion: apiserver.config.k8s.io/v1
|
|
3406
|
+
* kind: EncryptionConfiguration
|
|
3407
|
+
* resources:
|
|
3408
|
+
* - resources:
|
|
3409
|
+
* - secrets
|
|
3410
|
+
* providers:
|
|
3411
|
+
* - aescbc:
|
|
3412
|
+
* keys:
|
|
3413
|
+
* - name: k-fw5hn
|
|
3414
|
+
* secret: RTczRjFDODMwQzAyMDVBREU4NDJBMUZFNDhCNzM5N0I=
|
|
3415
|
+
* identity: {}
|
|
3416
|
+
* EOF
|
|
3417
|
+
*
|
|
3418
|
+
* ```
|
|
3419
|
+
*/
|
|
2337
3420
|
customConfig?: pulumi.Input<string>;
|
|
3421
|
+
/**
|
|
3422
|
+
* Enable the authorized cluster endpoint. Default `true` (bool)
|
|
3423
|
+
*/
|
|
2338
3424
|
enabled?: pulumi.Input<boolean>;
|
|
2339
3425
|
}
|
|
2340
3426
|
export interface ClusterRkeConfigServicesKubeController {
|
|
3427
|
+
/**
|
|
3428
|
+
* Cluster CIDR option for kube controller service (string)
|
|
3429
|
+
*/
|
|
2341
3430
|
clusterCidr?: pulumi.Input<string>;
|
|
3431
|
+
/**
|
|
3432
|
+
* Extra arguments for scheduler service (map)
|
|
3433
|
+
*/
|
|
2342
3434
|
extraArgs?: pulumi.Input<{
|
|
2343
3435
|
[key: string]: any;
|
|
2344
3436
|
}>;
|
|
3437
|
+
/**
|
|
3438
|
+
* Extra binds for scheduler service (list)
|
|
3439
|
+
*/
|
|
2345
3440
|
extraBinds?: pulumi.Input<pulumi.Input<string>[]>;
|
|
3441
|
+
/**
|
|
3442
|
+
* Extra environment for scheduler service (list)
|
|
3443
|
+
*/
|
|
2346
3444
|
extraEnvs?: pulumi.Input<pulumi.Input<string>[]>;
|
|
3445
|
+
/**
|
|
3446
|
+
* Docker image for scheduler service (string)
|
|
3447
|
+
*/
|
|
2347
3448
|
image?: pulumi.Input<string>;
|
|
3449
|
+
/**
|
|
3450
|
+
* Service Cluster ip Range option for kube controller service (string)
|
|
3451
|
+
*/
|
|
2348
3452
|
serviceClusterIpRange?: pulumi.Input<string>;
|
|
2349
3453
|
}
|
|
2350
3454
|
export interface ClusterRkeConfigServicesKubelet {
|
|
3455
|
+
/**
|
|
3456
|
+
* Cluster DNS Server option for kubelet service (string)
|
|
3457
|
+
*/
|
|
2351
3458
|
clusterDnsServer?: pulumi.Input<string>;
|
|
3459
|
+
/**
|
|
3460
|
+
* Cluster Domain option for kubelet service (string)
|
|
3461
|
+
*/
|
|
2352
3462
|
clusterDomain?: pulumi.Input<string>;
|
|
3463
|
+
/**
|
|
3464
|
+
* Extra arguments for scheduler service (map)
|
|
3465
|
+
*/
|
|
2353
3466
|
extraArgs?: pulumi.Input<{
|
|
2354
3467
|
[key: string]: any;
|
|
2355
3468
|
}>;
|
|
3469
|
+
/**
|
|
3470
|
+
* Extra binds for scheduler service (list)
|
|
3471
|
+
*/
|
|
2356
3472
|
extraBinds?: pulumi.Input<pulumi.Input<string>[]>;
|
|
3473
|
+
/**
|
|
3474
|
+
* Extra environment for scheduler service (list)
|
|
3475
|
+
*/
|
|
2357
3476
|
extraEnvs?: pulumi.Input<pulumi.Input<string>[]>;
|
|
3477
|
+
/**
|
|
3478
|
+
* Enable or disable failing when swap on is not supported (bool)
|
|
3479
|
+
*/
|
|
2358
3480
|
failSwapOn?: pulumi.Input<boolean>;
|
|
3481
|
+
/**
|
|
3482
|
+
* [Generate a certificate signed by the kube-ca](https://rancher.com/docs/rke/latest/en/config-options/services/#kubelet-serving-certificate-requirements). Default `false` (bool)
|
|
3483
|
+
*/
|
|
2359
3484
|
generateServingCertificate?: pulumi.Input<boolean>;
|
|
3485
|
+
/**
|
|
3486
|
+
* Docker image for scheduler service (string)
|
|
3487
|
+
*/
|
|
2360
3488
|
image?: pulumi.Input<string>;
|
|
3489
|
+
/**
|
|
3490
|
+
* Infra container image for kubelet service (string)
|
|
3491
|
+
*/
|
|
2361
3492
|
infraContainerImage?: pulumi.Input<string>;
|
|
2362
3493
|
}
|
|
2363
3494
|
export interface ClusterRkeConfigServicesKubeproxy {
|
|
3495
|
+
/**
|
|
3496
|
+
* Extra arguments for scheduler service (map)
|
|
3497
|
+
*/
|
|
2364
3498
|
extraArgs?: pulumi.Input<{
|
|
2365
3499
|
[key: string]: any;
|
|
2366
3500
|
}>;
|
|
3501
|
+
/**
|
|
3502
|
+
* Extra binds for scheduler service (list)
|
|
3503
|
+
*/
|
|
2367
3504
|
extraBinds?: pulumi.Input<pulumi.Input<string>[]>;
|
|
3505
|
+
/**
|
|
3506
|
+
* Extra environment for scheduler service (list)
|
|
3507
|
+
*/
|
|
2368
3508
|
extraEnvs?: pulumi.Input<pulumi.Input<string>[]>;
|
|
3509
|
+
/**
|
|
3510
|
+
* Docker image for scheduler service (string)
|
|
3511
|
+
*/
|
|
2369
3512
|
image?: pulumi.Input<string>;
|
|
2370
3513
|
}
|
|
2371
3514
|
export interface ClusterRkeConfigServicesScheduler {
|
|
3515
|
+
/**
|
|
3516
|
+
* Extra arguments for scheduler service (map)
|
|
3517
|
+
*/
|
|
2372
3518
|
extraArgs?: pulumi.Input<{
|
|
2373
3519
|
[key: string]: any;
|
|
2374
3520
|
}>;
|
|
3521
|
+
/**
|
|
3522
|
+
* Extra binds for scheduler service (list)
|
|
3523
|
+
*/
|
|
2375
3524
|
extraBinds?: pulumi.Input<pulumi.Input<string>[]>;
|
|
3525
|
+
/**
|
|
3526
|
+
* Extra environment for scheduler service (list)
|
|
3527
|
+
*/
|
|
2376
3528
|
extraEnvs?: pulumi.Input<pulumi.Input<string>[]>;
|
|
3529
|
+
/**
|
|
3530
|
+
* Docker image for scheduler service (string)
|
|
3531
|
+
*/
|
|
2377
3532
|
image?: pulumi.Input<string>;
|
|
2378
3533
|
}
|
|
2379
3534
|
export interface ClusterRkeConfigUpgradeStrategy {
|
|
3535
|
+
/**
|
|
3536
|
+
* RKE drain nodes. Default: `false` (bool)
|
|
3537
|
+
*/
|
|
2380
3538
|
drain?: pulumi.Input<boolean>;
|
|
3539
|
+
/**
|
|
3540
|
+
* RKE drain node input (list Maxitems: 1)
|
|
3541
|
+
*/
|
|
2381
3542
|
drainInput?: pulumi.Input<inputs.ClusterRkeConfigUpgradeStrategyDrainInput>;
|
|
3543
|
+
/**
|
|
3544
|
+
* RKE max unavailable controlplane nodes. Default: `1` (string)
|
|
3545
|
+
*/
|
|
2382
3546
|
maxUnavailableControlplane?: pulumi.Input<string>;
|
|
3547
|
+
/**
|
|
3548
|
+
* RKE max unavailable worker nodes. Default: `10%` (string)
|
|
3549
|
+
*/
|
|
2383
3550
|
maxUnavailableWorker?: pulumi.Input<string>;
|
|
2384
3551
|
}
|
|
2385
3552
|
export interface ClusterRkeConfigUpgradeStrategyDrainInput {
|
|
3553
|
+
/**
|
|
3554
|
+
* Delete RKE node local data. Default: `false` (bool)
|
|
3555
|
+
*/
|
|
2386
3556
|
deleteLocalData?: pulumi.Input<boolean>;
|
|
3557
|
+
/**
|
|
3558
|
+
* Force RKE node drain. Default: `false` (bool)
|
|
3559
|
+
*/
|
|
2387
3560
|
force?: pulumi.Input<boolean>;
|
|
3561
|
+
/**
|
|
3562
|
+
* RKE node drain grace period. Default: `-1` (int)
|
|
3563
|
+
*/
|
|
2388
3564
|
gracePeriod?: pulumi.Input<number>;
|
|
3565
|
+
/**
|
|
3566
|
+
* Ignore RKE daemon sets. Default: `true` (bool)
|
|
3567
|
+
*/
|
|
2389
3568
|
ignoreDaemonSets?: pulumi.Input<boolean>;
|
|
3569
|
+
/**
|
|
3570
|
+
* RKE node drain timeout. Default: `60` (int)
|
|
3571
|
+
*/
|
|
2390
3572
|
timeout?: pulumi.Input<number>;
|
|
2391
3573
|
}
|
|
2392
3574
|
export interface ClusterSyncNode {
|
|
@@ -2396,6 +3578,9 @@ export interface ClusterSyncNode {
|
|
|
2396
3578
|
annotations?: pulumi.Input<{
|
|
2397
3579
|
[key: string]: any;
|
|
2398
3580
|
}>;
|
|
3581
|
+
/**
|
|
3582
|
+
* The total resources of a node (map).
|
|
3583
|
+
*/
|
|
2399
3584
|
capacity?: pulumi.Input<{
|
|
2400
3585
|
[key: string]: any;
|
|
2401
3586
|
}>;
|
|
@@ -2403,12 +3588,21 @@ export interface ClusterSyncNode {
|
|
|
2403
3588
|
* The cluster ID that is syncing (string)
|
|
2404
3589
|
*/
|
|
2405
3590
|
clusterId?: pulumi.Input<string>;
|
|
3591
|
+
/**
|
|
3592
|
+
* The external IP address of the node (string).
|
|
3593
|
+
*/
|
|
2406
3594
|
externalIpAddress?: pulumi.Input<string>;
|
|
3595
|
+
/**
|
|
3596
|
+
* The hostname of the node (string).
|
|
3597
|
+
*/
|
|
2407
3598
|
hostname?: pulumi.Input<string>;
|
|
2408
3599
|
/**
|
|
2409
3600
|
* (Computed) The ID of the resource. Same as `clusterId` (string)
|
|
2410
3601
|
*/
|
|
2411
3602
|
id?: pulumi.Input<string>;
|
|
3603
|
+
/**
|
|
3604
|
+
* The private IP address of the node (string).
|
|
3605
|
+
*/
|
|
2412
3606
|
ipAddress?: pulumi.Input<string>;
|
|
2413
3607
|
/**
|
|
2414
3608
|
* Labels of the resource
|
|
@@ -2416,13 +3610,37 @@ export interface ClusterSyncNode {
|
|
|
2416
3610
|
labels?: pulumi.Input<{
|
|
2417
3611
|
[key: string]: any;
|
|
2418
3612
|
}>;
|
|
3613
|
+
/**
|
|
3614
|
+
* The name of the node (string).
|
|
3615
|
+
*/
|
|
2419
3616
|
name?: pulumi.Input<string>;
|
|
3617
|
+
/**
|
|
3618
|
+
* The Node Pool ID of the node (string).
|
|
3619
|
+
*/
|
|
2420
3620
|
nodePoolId?: pulumi.Input<string>;
|
|
3621
|
+
/**
|
|
3622
|
+
* The Node Template ID of the node (string).
|
|
3623
|
+
*/
|
|
2421
3624
|
nodeTemplateId?: pulumi.Input<string>;
|
|
3625
|
+
/**
|
|
3626
|
+
* The Provider ID of the node (string).
|
|
3627
|
+
*/
|
|
2422
3628
|
providerId?: pulumi.Input<string>;
|
|
3629
|
+
/**
|
|
3630
|
+
* The requested hostname (string).
|
|
3631
|
+
*/
|
|
2423
3632
|
requestedHostname?: pulumi.Input<string>;
|
|
3633
|
+
/**
|
|
3634
|
+
* Roles of the node. `controlplane`, `etcd` and `worker`. (list)
|
|
3635
|
+
*/
|
|
2424
3636
|
roles?: pulumi.Input<pulumi.Input<string>[]>;
|
|
3637
|
+
/**
|
|
3638
|
+
* The user to connect to the node (string).
|
|
3639
|
+
*/
|
|
2425
3640
|
sshUser?: pulumi.Input<string>;
|
|
3641
|
+
/**
|
|
3642
|
+
* General information about the node, such as kernel version, kubelet and kube-proxy version, Docker version (if used), and OS name.
|
|
3643
|
+
*/
|
|
2426
3644
|
systemInfo?: pulumi.Input<{
|
|
2427
3645
|
[key: string]: any;
|
|
2428
3646
|
}>;
|
|
@@ -2535,6 +3753,9 @@ export interface ClusterTemplateTemplateRevisionClusterConfig {
|
|
|
2535
3753
|
}
|
|
2536
3754
|
export interface ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpoint {
|
|
2537
3755
|
caCerts?: pulumi.Input<string>;
|
|
3756
|
+
/**
|
|
3757
|
+
* Enable cluster template revision. Default `true` (bool)
|
|
3758
|
+
*/
|
|
2538
3759
|
enabled?: pulumi.Input<boolean>;
|
|
2539
3760
|
fqdn?: pulumi.Input<string>;
|
|
2540
3761
|
}
|
|
@@ -3133,6 +4354,9 @@ export interface ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEt
|
|
|
3133
4354
|
uid?: pulumi.Input<number>;
|
|
3134
4355
|
}
|
|
3135
4356
|
export interface ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfig {
|
|
4357
|
+
/**
|
|
4358
|
+
* Enable cluster template revision. Default `true` (bool)
|
|
4359
|
+
*/
|
|
3136
4360
|
enabled?: pulumi.Input<boolean>;
|
|
3137
4361
|
intervalHours?: pulumi.Input<number>;
|
|
3138
4362
|
retention?: pulumi.Input<number>;
|
|
@@ -3198,6 +4422,9 @@ export interface ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKu
|
|
|
3198
4422
|
}
|
|
3199
4423
|
export interface ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLog {
|
|
3200
4424
|
configuration?: pulumi.Input<inputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfiguration>;
|
|
4425
|
+
/**
|
|
4426
|
+
* Enable cluster template revision. Default `true` (bool)
|
|
4427
|
+
*/
|
|
3201
4428
|
enabled?: pulumi.Input<boolean>;
|
|
3202
4429
|
}
|
|
3203
4430
|
export interface ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfiguration {
|
|
@@ -3210,10 +4437,16 @@ export interface ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKu
|
|
|
3210
4437
|
}
|
|
3211
4438
|
export interface ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimit {
|
|
3212
4439
|
configuration?: pulumi.Input<string>;
|
|
4440
|
+
/**
|
|
4441
|
+
* Enable cluster template revision. Default `true` (bool)
|
|
4442
|
+
*/
|
|
3213
4443
|
enabled?: pulumi.Input<boolean>;
|
|
3214
4444
|
}
|
|
3215
4445
|
export interface ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfig {
|
|
3216
4446
|
customConfig?: pulumi.Input<string>;
|
|
4447
|
+
/**
|
|
4448
|
+
* Enable cluster template revision. Default `true` (bool)
|
|
4449
|
+
*/
|
|
3217
4450
|
enabled?: pulumi.Input<boolean>;
|
|
3218
4451
|
}
|
|
3219
4452
|
export interface ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeController {
|
|
@@ -3291,6 +4524,9 @@ export interface ClusterV2AgentEnvVar {
|
|
|
3291
4524
|
* The name of the cluster.
|
|
3292
4525
|
*/
|
|
3293
4526
|
name: pulumi.Input<string>;
|
|
4527
|
+
/**
|
|
4528
|
+
* The taint value.
|
|
4529
|
+
*/
|
|
3294
4530
|
value: pulumi.Input<string>;
|
|
3295
4531
|
}
|
|
3296
4532
|
export interface ClusterV2ClusterAgentDeploymentCustomization {
|
|
@@ -3308,10 +4544,25 @@ export interface ClusterV2ClusterAgentDeploymentCustomization {
|
|
|
3308
4544
|
overrideResourceRequirements?: pulumi.Input<pulumi.Input<inputs.ClusterV2ClusterAgentDeploymentCustomizationOverrideResourceRequirement>[]>;
|
|
3309
4545
|
}
|
|
3310
4546
|
export interface ClusterV2ClusterAgentDeploymentCustomizationAppendToleration {
|
|
4547
|
+
/**
|
|
4548
|
+
* The taint effect. Default: `\"NoExecute\"`.
|
|
4549
|
+
*/
|
|
3311
4550
|
effect?: pulumi.Input<string>;
|
|
4551
|
+
/**
|
|
4552
|
+
* Key is the name of the key of the item to retrieve.
|
|
4553
|
+
*/
|
|
3312
4554
|
key: pulumi.Input<string>;
|
|
4555
|
+
/**
|
|
4556
|
+
* Operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
|
|
4557
|
+
*/
|
|
3313
4558
|
operator?: pulumi.Input<string>;
|
|
4559
|
+
/**
|
|
4560
|
+
* The number of seconds a pod will stay bound to a node with a matching taint.
|
|
4561
|
+
*/
|
|
3314
4562
|
seconds?: pulumi.Input<number>;
|
|
4563
|
+
/**
|
|
4564
|
+
* The taint value.
|
|
4565
|
+
*/
|
|
3315
4566
|
value?: pulumi.Input<string>;
|
|
3316
4567
|
}
|
|
3317
4568
|
export interface ClusterV2ClusterAgentDeploymentCustomizationOverrideResourceRequirement {
|
|
@@ -3339,14 +4590,29 @@ export interface ClusterV2ClusterRegistrationToken {
|
|
|
3339
4590
|
annotations?: pulumi.Input<{
|
|
3340
4591
|
[key: string]: any;
|
|
3341
4592
|
}>;
|
|
4593
|
+
/**
|
|
4594
|
+
* Cluster ID.
|
|
4595
|
+
*/
|
|
3342
4596
|
clusterId?: pulumi.Input<string>;
|
|
4597
|
+
/**
|
|
4598
|
+
* Command to execute in an imported k8s cluster.
|
|
4599
|
+
*/
|
|
3343
4600
|
command?: pulumi.Input<string>;
|
|
3344
4601
|
/**
|
|
3345
4602
|
* (Computed, string) The ID of the resource.
|
|
3346
4603
|
*/
|
|
3347
4604
|
id?: pulumi.Input<string>;
|
|
4605
|
+
/**
|
|
4606
|
+
* Insecure command to execute in an imported k8s cluster.
|
|
4607
|
+
*/
|
|
3348
4608
|
insecureCommand?: pulumi.Input<string>;
|
|
4609
|
+
/**
|
|
4610
|
+
* Insecure node command to execute in an imported k8s cluster.
|
|
4611
|
+
*/
|
|
3349
4612
|
insecureNodeCommand?: pulumi.Input<string>;
|
|
4613
|
+
/**
|
|
4614
|
+
* Insecure windows command to execute in an imported k8s cluster.
|
|
4615
|
+
*/
|
|
3350
4616
|
insecureWindowsNodeCommand?: pulumi.Input<string>;
|
|
3351
4617
|
/**
|
|
3352
4618
|
* Labels for the Cluster.
|
|
@@ -3354,13 +4620,25 @@ export interface ClusterV2ClusterRegistrationToken {
|
|
|
3354
4620
|
labels?: pulumi.Input<{
|
|
3355
4621
|
[key: string]: any;
|
|
3356
4622
|
}>;
|
|
4623
|
+
/**
|
|
4624
|
+
* K8s manifest url to execute with `kubectl` to import an existing k8s cluster.
|
|
4625
|
+
*/
|
|
3357
4626
|
manifestUrl?: pulumi.Input<string>;
|
|
3358
4627
|
/**
|
|
3359
4628
|
* The name of the cluster.
|
|
3360
4629
|
*/
|
|
3361
4630
|
name?: pulumi.Input<string>;
|
|
4631
|
+
/**
|
|
4632
|
+
* Node command to execute in Linux nodes for custom k8s cluster.
|
|
4633
|
+
*/
|
|
3362
4634
|
nodeCommand?: pulumi.Input<string>;
|
|
4635
|
+
/**
|
|
4636
|
+
* Token for cluster registration token object.
|
|
4637
|
+
*/
|
|
3363
4638
|
token?: pulumi.Input<string>;
|
|
4639
|
+
/**
|
|
4640
|
+
* Node command to execute in Windows nodes for custom k8s cluster.
|
|
4641
|
+
*/
|
|
3364
4642
|
windowsNodeCommand?: pulumi.Input<string>;
|
|
3365
4643
|
}
|
|
3366
4644
|
export interface ClusterV2FleetAgentDeploymentCustomization {
|
|
@@ -3378,10 +4656,25 @@ export interface ClusterV2FleetAgentDeploymentCustomization {
|
|
|
3378
4656
|
overrideResourceRequirements?: pulumi.Input<pulumi.Input<inputs.ClusterV2FleetAgentDeploymentCustomizationOverrideResourceRequirement>[]>;
|
|
3379
4657
|
}
|
|
3380
4658
|
export interface ClusterV2FleetAgentDeploymentCustomizationAppendToleration {
|
|
4659
|
+
/**
|
|
4660
|
+
* The taint effect. Default: `\"NoExecute\"`.
|
|
4661
|
+
*/
|
|
3381
4662
|
effect?: pulumi.Input<string>;
|
|
4663
|
+
/**
|
|
4664
|
+
* Key is the name of the key of the item to retrieve.
|
|
4665
|
+
*/
|
|
3382
4666
|
key: pulumi.Input<string>;
|
|
4667
|
+
/**
|
|
4668
|
+
* Operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
|
|
4669
|
+
*/
|
|
3383
4670
|
operator?: pulumi.Input<string>;
|
|
4671
|
+
/**
|
|
4672
|
+
* The number of seconds a pod will stay bound to a node with a matching taint.
|
|
4673
|
+
*/
|
|
3384
4674
|
seconds?: pulumi.Input<number>;
|
|
4675
|
+
/**
|
|
4676
|
+
* The taint value.
|
|
4677
|
+
*/
|
|
3385
4678
|
value?: pulumi.Input<string>;
|
|
3386
4679
|
}
|
|
3387
4680
|
export interface ClusterV2FleetAgentDeploymentCustomizationOverrideResourceRequirement {
|
|
@@ -3403,8 +4696,17 @@ export interface ClusterV2FleetAgentDeploymentCustomizationOverrideResourceRequi
|
|
|
3403
4696
|
memoryRequest?: pulumi.Input<string>;
|
|
3404
4697
|
}
|
|
3405
4698
|
export interface ClusterV2LocalAuthEndpoint {
|
|
4699
|
+
/**
|
|
4700
|
+
* CA certs for the authorized cluster endpoint. It is only needed if there is a load balancer in front of the downstream cluster that is using an untrusted certificate. If you have a valid certificate, then nothing needs to be added to the CA Certificates field.
|
|
4701
|
+
*/
|
|
3406
4702
|
caCerts?: pulumi.Input<string>;
|
|
4703
|
+
/**
|
|
4704
|
+
* If `enabled` is set to true, nodes will be drained before upgrade.
|
|
4705
|
+
*/
|
|
3407
4706
|
enabled?: pulumi.Input<boolean>;
|
|
4707
|
+
/**
|
|
4708
|
+
* FQDN for the authorized cluster endpoint. If one is entered, it should point to the downstream cluster.
|
|
4709
|
+
*/
|
|
3408
4710
|
fqdn?: pulumi.Input<string>;
|
|
3409
4711
|
}
|
|
3410
4712
|
export interface ClusterV2RkeConfig {
|
|
@@ -3536,8 +4838,17 @@ export interface ClusterV2RkeConfigEtcdSnapshotRestore {
|
|
|
3536
4838
|
restoreRkeConfig?: pulumi.Input<string>;
|
|
3537
4839
|
}
|
|
3538
4840
|
export interface ClusterV2RkeConfigLocalAuthEndpoint {
|
|
4841
|
+
/**
|
|
4842
|
+
* CA certs for the authorized cluster endpoint. It is only needed if there is a load balancer in front of the downstream cluster that is using an untrusted certificate. If you have a valid certificate, then nothing needs to be added to the CA Certificates field.
|
|
4843
|
+
*/
|
|
3539
4844
|
caCerts?: pulumi.Input<string>;
|
|
4845
|
+
/**
|
|
4846
|
+
* If `enabled` is set to true, nodes will be drained before upgrade.
|
|
4847
|
+
*/
|
|
3540
4848
|
enabled?: pulumi.Input<boolean>;
|
|
4849
|
+
/**
|
|
4850
|
+
* FQDN for the authorized cluster endpoint. If one is entered, it should point to the downstream cluster.
|
|
4851
|
+
*/
|
|
3541
4852
|
fqdn?: pulumi.Input<string>;
|
|
3542
4853
|
}
|
|
3543
4854
|
export interface ClusterV2RkeConfigMachinePool {
|
|
@@ -3659,8 +4970,17 @@ export interface ClusterV2RkeConfigMachinePoolRollingUpdate {
|
|
|
3659
4970
|
maxUnavailable?: pulumi.Input<string>;
|
|
3660
4971
|
}
|
|
3661
4972
|
export interface ClusterV2RkeConfigMachinePoolTaint {
|
|
4973
|
+
/**
|
|
4974
|
+
* The taint effect. Default: `\"NoExecute\"`.
|
|
4975
|
+
*/
|
|
3662
4976
|
effect?: pulumi.Input<string>;
|
|
4977
|
+
/**
|
|
4978
|
+
* Key is the name of the key of the item to retrieve.
|
|
4979
|
+
*/
|
|
3663
4980
|
key: pulumi.Input<string>;
|
|
4981
|
+
/**
|
|
4982
|
+
* The taint value.
|
|
4983
|
+
*/
|
|
3664
4984
|
value: pulumi.Input<string>;
|
|
3665
4985
|
}
|
|
3666
4986
|
export interface ClusterV2RkeConfigMachineSelectorConfig {
|
|
@@ -3970,20 +5290,53 @@ export interface ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptions {
|
|
|
3970
5290
|
timeout?: pulumi.Input<number>;
|
|
3971
5291
|
}
|
|
3972
5292
|
export interface EtcdBackupBackupConfig {
|
|
5293
|
+
/**
|
|
5294
|
+
* Enable etcd backup (bool)
|
|
5295
|
+
*/
|
|
3973
5296
|
enabled?: pulumi.Input<boolean>;
|
|
5297
|
+
/**
|
|
5298
|
+
* Interval hours for etcd backup. Default `12` (int)
|
|
5299
|
+
*/
|
|
3974
5300
|
intervalHours?: pulumi.Input<number>;
|
|
5301
|
+
/**
|
|
5302
|
+
* Retention for etcd backup. Default `6` (int)
|
|
5303
|
+
*/
|
|
3975
5304
|
retention?: pulumi.Input<number>;
|
|
5305
|
+
/**
|
|
5306
|
+
* S3 config options for etcd backup. Valid for `imported` and `rke` clusters. (list maxitems:1)
|
|
5307
|
+
*/
|
|
3976
5308
|
s3BackupConfig?: pulumi.Input<inputs.EtcdBackupBackupConfigS3BackupConfig>;
|
|
3977
5309
|
safeTimestamp?: pulumi.Input<boolean>;
|
|
3978
5310
|
timeout?: pulumi.Input<number>;
|
|
3979
5311
|
}
|
|
3980
5312
|
export interface EtcdBackupBackupConfigS3BackupConfig {
|
|
5313
|
+
/**
|
|
5314
|
+
* Access key for S3 service (string)
|
|
5315
|
+
*/
|
|
3981
5316
|
accessKey?: pulumi.Input<string>;
|
|
5317
|
+
/**
|
|
5318
|
+
* Bucket name for S3 service (string)
|
|
5319
|
+
*/
|
|
3982
5320
|
bucketName: pulumi.Input<string>;
|
|
5321
|
+
/**
|
|
5322
|
+
* Base64 encoded custom CA for S3 service. Use filebase64(<FILE>) for encoding file. Available from Rancher v2.2.5 (string)
|
|
5323
|
+
*/
|
|
3983
5324
|
customCa?: pulumi.Input<string>;
|
|
5325
|
+
/**
|
|
5326
|
+
* Endpoint for S3 service (string)
|
|
5327
|
+
*/
|
|
3984
5328
|
endpoint: pulumi.Input<string>;
|
|
5329
|
+
/**
|
|
5330
|
+
* Folder for S3 service. Available from Rancher v2.2.7 (string)
|
|
5331
|
+
*/
|
|
3985
5332
|
folder?: pulumi.Input<string>;
|
|
5333
|
+
/**
|
|
5334
|
+
* Region for S3 service (string)
|
|
5335
|
+
*/
|
|
3986
5336
|
region?: pulumi.Input<string>;
|
|
5337
|
+
/**
|
|
5338
|
+
* Secret key for S3 service (string)
|
|
5339
|
+
*/
|
|
3987
5340
|
secretKey?: pulumi.Input<string>;
|
|
3988
5341
|
}
|
|
3989
5342
|
export interface GetNotifierDingtalkConfig {
|
|
@@ -4379,20 +5732,53 @@ export interface GetRoleTemplateExternalRuleArgs {
|
|
|
4379
5732
|
verbs?: pulumi.Input<pulumi.Input<string>[]>;
|
|
4380
5733
|
}
|
|
4381
5734
|
export interface GlobalDnsProviderAlidnsConfig {
|
|
5735
|
+
/**
|
|
5736
|
+
* The AWS Access key (string)
|
|
5737
|
+
*/
|
|
4382
5738
|
accessKey: pulumi.Input<string>;
|
|
5739
|
+
/**
|
|
5740
|
+
* The AWS Secret key (string)
|
|
5741
|
+
*/
|
|
4383
5742
|
secretKey: pulumi.Input<string>;
|
|
4384
5743
|
}
|
|
4385
5744
|
export interface GlobalDnsProviderCloudflareConfig {
|
|
5745
|
+
/**
|
|
5746
|
+
* The CloudFlare API Email (string)
|
|
5747
|
+
*/
|
|
4386
5748
|
apiEmail: pulumi.Input<string>;
|
|
5749
|
+
/**
|
|
5750
|
+
* The CloudFlare API Key (string)
|
|
5751
|
+
*/
|
|
4387
5752
|
apiKey: pulumi.Input<string>;
|
|
5753
|
+
/**
|
|
5754
|
+
* CloudFlare Proxy Setting. Default: `false` (bool)
|
|
5755
|
+
*/
|
|
4388
5756
|
proxySetting?: pulumi.Input<boolean>;
|
|
4389
5757
|
}
|
|
4390
5758
|
export interface GlobalDnsProviderRoute53Config {
|
|
5759
|
+
/**
|
|
5760
|
+
* The AWS Access key (string)
|
|
5761
|
+
*/
|
|
4391
5762
|
accessKey: pulumi.Input<string>;
|
|
5763
|
+
/**
|
|
5764
|
+
* The AWS credentials path. Default: `"/.aws"` (string)
|
|
5765
|
+
*/
|
|
4392
5766
|
credentialsPath?: pulumi.Input<string>;
|
|
5767
|
+
/**
|
|
5768
|
+
* The AWS Region. Default: `"us-west-2"` (string)
|
|
5769
|
+
*/
|
|
4393
5770
|
region?: pulumi.Input<string>;
|
|
5771
|
+
/**
|
|
5772
|
+
* The AWS Role ARN (string)
|
|
5773
|
+
*/
|
|
4394
5774
|
roleArn?: pulumi.Input<string>;
|
|
5775
|
+
/**
|
|
5776
|
+
* The AWS Secret key (string)
|
|
5777
|
+
*/
|
|
4395
5778
|
secretKey: pulumi.Input<string>;
|
|
5779
|
+
/**
|
|
5780
|
+
* The Route53 zone type `public, private`. Default: `"public"` (string)
|
|
5781
|
+
*/
|
|
4396
5782
|
zoneType?: pulumi.Input<string>;
|
|
4397
5783
|
}
|
|
4398
5784
|
export interface GlobalRoleRule {
|
|
@@ -4886,47 +6272,176 @@ export interface MachineConfigV2LinodeConfig {
|
|
|
4886
6272
|
uaPrefix?: pulumi.Input<string>;
|
|
4887
6273
|
}
|
|
4888
6274
|
export interface MachineConfigV2OpenstackConfig {
|
|
6275
|
+
/**
|
|
6276
|
+
* OpenStack active timeout Default `200` (string)
|
|
6277
|
+
*/
|
|
4889
6278
|
activeTimeout?: pulumi.Input<string>;
|
|
6279
|
+
/**
|
|
6280
|
+
* OpenStack application credential id. Conflicts with `applicationCredentialName` (string)
|
|
6281
|
+
*/
|
|
4890
6282
|
applicationCredentialId?: pulumi.Input<string>;
|
|
6283
|
+
/**
|
|
6284
|
+
* OpenStack application credential name. Conflicts with `applicationCredentialId` (string)
|
|
6285
|
+
*/
|
|
4891
6286
|
applicationCredentialName?: pulumi.Input<string>;
|
|
6287
|
+
/**
|
|
6288
|
+
* OpenStack application credential secret (string)
|
|
6289
|
+
*/
|
|
4892
6290
|
applicationCredentialSecret?: pulumi.Input<string>;
|
|
6291
|
+
/**
|
|
6292
|
+
* OpenStack authentication URL (string)
|
|
6293
|
+
*/
|
|
4893
6294
|
authUrl: pulumi.Input<string>;
|
|
6295
|
+
/**
|
|
6296
|
+
* OpenStack availability zone (string)
|
|
6297
|
+
*/
|
|
4894
6298
|
availabilityZone: pulumi.Input<string>;
|
|
6299
|
+
/**
|
|
6300
|
+
* Enable booting from volume. Default is `false` (bool)
|
|
6301
|
+
*/
|
|
4895
6302
|
bootFromVolume?: pulumi.Input<boolean>;
|
|
6303
|
+
/**
|
|
6304
|
+
* CA certificate bundle to verify against (string)
|
|
6305
|
+
*/
|
|
4896
6306
|
cacert?: pulumi.Input<string>;
|
|
6307
|
+
/**
|
|
6308
|
+
* Enables the OpenStack config drive for the instance. Default `false` (bool)
|
|
6309
|
+
*/
|
|
4897
6310
|
configDrive?: pulumi.Input<boolean>;
|
|
6311
|
+
/**
|
|
6312
|
+
* OpenStack domain ID. Identity v3 only. Conflicts with `domainName` (string)
|
|
6313
|
+
*/
|
|
4898
6314
|
domainId?: pulumi.Input<string>;
|
|
6315
|
+
/**
|
|
6316
|
+
* OpenStack domain name. Identity v3 only. Conflicts with `domainId` (string)
|
|
6317
|
+
*/
|
|
4899
6318
|
domainName?: pulumi.Input<string>;
|
|
6319
|
+
/**
|
|
6320
|
+
* OpenStack endpoint type. adminURL, internalURL or publicURL (string)
|
|
6321
|
+
*/
|
|
4900
6322
|
endpointType?: pulumi.Input<string>;
|
|
6323
|
+
/**
|
|
6324
|
+
* OpenStack flavor id to use for the instance. Conflicts with `flavorName` (string)
|
|
6325
|
+
*/
|
|
4901
6326
|
flavorId?: pulumi.Input<string>;
|
|
6327
|
+
/**
|
|
6328
|
+
* OpenStack flavor name to use for the instance. Conflicts with `flavorId` (string)
|
|
6329
|
+
*/
|
|
4902
6330
|
flavorName?: pulumi.Input<string>;
|
|
6331
|
+
/**
|
|
6332
|
+
* OpenStack floating IP pool to get an IP from to assign to the instance (string)
|
|
6333
|
+
*/
|
|
4903
6334
|
floatingIpPool?: pulumi.Input<string>;
|
|
6335
|
+
/**
|
|
6336
|
+
* OpenStack image id to use for the instance. Conflicts with `imageName` (string)
|
|
6337
|
+
*/
|
|
4904
6338
|
imageId?: pulumi.Input<string>;
|
|
6339
|
+
/**
|
|
6340
|
+
* OpenStack image name to use for the instance. Conflicts with `imageId` (string)
|
|
6341
|
+
*/
|
|
4905
6342
|
imageName?: pulumi.Input<string>;
|
|
6343
|
+
/**
|
|
6344
|
+
* Disable TLS credential checking. Default `false` (bool)
|
|
6345
|
+
*/
|
|
4906
6346
|
insecure?: pulumi.Input<boolean>;
|
|
6347
|
+
/**
|
|
6348
|
+
* OpenStack version of IP address assigned for the machine Default `4` (string)
|
|
6349
|
+
*/
|
|
4907
6350
|
ipVersion?: pulumi.Input<string>;
|
|
6351
|
+
/**
|
|
6352
|
+
* OpenStack keypair to use to SSH to the instance (string)
|
|
6353
|
+
*/
|
|
4908
6354
|
keypairName?: pulumi.Input<string>;
|
|
6355
|
+
/**
|
|
6356
|
+
* OpenStack network id the machine will be connected on. Conflicts with `netName` (string)
|
|
6357
|
+
*/
|
|
4909
6358
|
netId?: pulumi.Input<string>;
|
|
6359
|
+
/**
|
|
6360
|
+
* OpenStack network name the machine will be connected on. Conflicts with `netId` (string)
|
|
6361
|
+
*/
|
|
4910
6362
|
netName?: pulumi.Input<string>;
|
|
6363
|
+
/**
|
|
6364
|
+
* Use the nova networking services instead of neutron (string)
|
|
6365
|
+
*/
|
|
4911
6366
|
novaNetwork?: pulumi.Input<boolean>;
|
|
6367
|
+
/**
|
|
6368
|
+
* OpenStack password. Mandatory on Rancher v2.0.x and v2.1.x. Use `rancher2.CloudCredential` from Rancher v2.2.x (string)
|
|
6369
|
+
*/
|
|
4912
6370
|
password?: pulumi.Input<string>;
|
|
6371
|
+
/**
|
|
6372
|
+
* Private key content to use for SSH (string)
|
|
6373
|
+
*/
|
|
4913
6374
|
privateKeyFile?: pulumi.Input<string>;
|
|
6375
|
+
/**
|
|
6376
|
+
* OpenStack region name (string)
|
|
6377
|
+
*/
|
|
4914
6378
|
region: pulumi.Input<string>;
|
|
6379
|
+
/**
|
|
6380
|
+
* OpenStack comma separated security groups for the machine (string)
|
|
6381
|
+
*/
|
|
4915
6382
|
secGroups?: pulumi.Input<string>;
|
|
6383
|
+
/**
|
|
6384
|
+
* If using a non-B2D image you can specify the ssh port. Default `22` (string)
|
|
6385
|
+
*/
|
|
4916
6386
|
sshPort?: pulumi.Input<string>;
|
|
6387
|
+
/**
|
|
6388
|
+
* If using a non-B2D image you can specify the ssh user. Default `docker`. (string)
|
|
6389
|
+
*/
|
|
4917
6390
|
sshUser?: pulumi.Input<string>;
|
|
6391
|
+
/**
|
|
6392
|
+
* OpenStack tenant domain id. Conflicts with `tenantDomainName` (string)
|
|
6393
|
+
*/
|
|
4918
6394
|
tenantDomainId?: pulumi.Input<string>;
|
|
6395
|
+
/**
|
|
6396
|
+
* OpenStack tenant domain name. Conflicts with `tenantDomainId` (string)
|
|
6397
|
+
*/
|
|
4919
6398
|
tenantDomainName?: pulumi.Input<string>;
|
|
6399
|
+
/**
|
|
6400
|
+
* OpenStack tenant id. Conflicts with `tenantName` (string)
|
|
6401
|
+
*/
|
|
4920
6402
|
tenantId?: pulumi.Input<string>;
|
|
6403
|
+
/**
|
|
6404
|
+
* OpenStack tenant name. Conflicts with `tenantId` (string)
|
|
6405
|
+
*/
|
|
4921
6406
|
tenantName?: pulumi.Input<string>;
|
|
6407
|
+
/**
|
|
6408
|
+
* File containing an openstack userdata script (string)
|
|
6409
|
+
*/
|
|
4922
6410
|
userDataFile?: pulumi.Input<string>;
|
|
6411
|
+
/**
|
|
6412
|
+
* OpenStack user domain id. Conflicts with `userDomainName` (string)
|
|
6413
|
+
*/
|
|
4923
6414
|
userDomainId?: pulumi.Input<string>;
|
|
6415
|
+
/**
|
|
6416
|
+
* OpenStack user domain name. Conflicts with `userDomainId` (string)
|
|
6417
|
+
*/
|
|
4924
6418
|
userDomainName?: pulumi.Input<string>;
|
|
6419
|
+
/**
|
|
6420
|
+
* OpenStack username (string)
|
|
6421
|
+
*/
|
|
4925
6422
|
username?: pulumi.Input<string>;
|
|
6423
|
+
/**
|
|
6424
|
+
* OpenStack volume device path (attaching). Applicable only when `bootFromVolume` is `true`. Omit for auto `/dev/vdb`. (string)
|
|
6425
|
+
* > **Note:**: `Required+` denotes that either the _name or _id is required but you cannot use both.
|
|
6426
|
+
* > **Note:**: `Required++` denotes that either the _name or _id is required unless `applicationCredentialId` is defined.
|
|
6427
|
+
* > **Note for OpenStack users:**: `keypairName` is required to be in the schema even if there are no references in rancher itself
|
|
6428
|
+
*/
|
|
4926
6429
|
volumeDevicePath?: pulumi.Input<string>;
|
|
6430
|
+
/**
|
|
6431
|
+
* OpenStack volume id of existing volume. Applicable only when `bootFromVolume` is `true` (string)
|
|
6432
|
+
*/
|
|
4927
6433
|
volumeId?: pulumi.Input<string>;
|
|
6434
|
+
/**
|
|
6435
|
+
* OpenStack volume name of existing volume. Applicable only when `bootFromVolume` is `true` (string)
|
|
6436
|
+
*/
|
|
4928
6437
|
volumeName?: pulumi.Input<string>;
|
|
6438
|
+
/**
|
|
6439
|
+
* OpenStack volume size (GiB). Required when `bootFromVolume` is `true` (string)
|
|
6440
|
+
*/
|
|
4929
6441
|
volumeSize?: pulumi.Input<string>;
|
|
6442
|
+
/**
|
|
6443
|
+
* OpenStack volume type. Required when `bootFromVolume` is `true` and openstack cloud does not have a default volume type (string)
|
|
6444
|
+
*/
|
|
4930
6445
|
volumeType?: pulumi.Input<string>;
|
|
4931
6446
|
}
|
|
4932
6447
|
export interface MachineConfigV2VsphereConfig {
|
|
@@ -5124,33 +6639,98 @@ export interface MultiClusterAppUpgradeStrategyRollingUpdate {
|
|
|
5124
6639
|
interval?: pulumi.Input<number>;
|
|
5125
6640
|
}
|
|
5126
6641
|
export interface NamespaceContainerResourceLimit {
|
|
6642
|
+
/**
|
|
6643
|
+
* Limit for limits cpu in namespace (string)
|
|
6644
|
+
*/
|
|
5127
6645
|
limitsCpu?: pulumi.Input<string>;
|
|
6646
|
+
/**
|
|
6647
|
+
* Limit for limits memory in namespace (string)
|
|
6648
|
+
*/
|
|
5128
6649
|
limitsMemory?: pulumi.Input<string>;
|
|
6650
|
+
/**
|
|
6651
|
+
* Limit for requests cpu in namespace (string)
|
|
6652
|
+
*/
|
|
5129
6653
|
requestsCpu?: pulumi.Input<string>;
|
|
6654
|
+
/**
|
|
6655
|
+
* Limit for requests memory in namespace (string)
|
|
6656
|
+
*/
|
|
5130
6657
|
requestsMemory?: pulumi.Input<string>;
|
|
5131
6658
|
}
|
|
5132
6659
|
export interface NamespaceResourceQuota {
|
|
6660
|
+
/**
|
|
6661
|
+
* Resource quota limit for namespace (list maxitems:1)
|
|
6662
|
+
*/
|
|
5133
6663
|
limit: pulumi.Input<inputs.NamespaceResourceQuotaLimit>;
|
|
5134
6664
|
}
|
|
5135
6665
|
export interface NamespaceResourceQuotaLimit {
|
|
6666
|
+
/**
|
|
6667
|
+
* Limit for config maps in namespace (string)
|
|
6668
|
+
*/
|
|
5136
6669
|
configMaps?: pulumi.Input<string>;
|
|
6670
|
+
/**
|
|
6671
|
+
* Limit for limits cpu in namespace (string)
|
|
6672
|
+
*/
|
|
5137
6673
|
limitsCpu?: pulumi.Input<string>;
|
|
6674
|
+
/**
|
|
6675
|
+
* Limit for limits memory in namespace (string)
|
|
6676
|
+
*/
|
|
5138
6677
|
limitsMemory?: pulumi.Input<string>;
|
|
6678
|
+
/**
|
|
6679
|
+
* Limit for persistent volume claims in namespace (string)
|
|
6680
|
+
*/
|
|
5139
6681
|
persistentVolumeClaims?: pulumi.Input<string>;
|
|
6682
|
+
/**
|
|
6683
|
+
* Limit for pods in namespace (string)
|
|
6684
|
+
*/
|
|
5140
6685
|
pods?: pulumi.Input<string>;
|
|
6686
|
+
/**
|
|
6687
|
+
* Limit for replication controllers in namespace (string)
|
|
6688
|
+
*/
|
|
5141
6689
|
replicationControllers?: pulumi.Input<string>;
|
|
6690
|
+
/**
|
|
6691
|
+
* Limit for requests cpu in namespace (string)
|
|
6692
|
+
*/
|
|
5142
6693
|
requestsCpu?: pulumi.Input<string>;
|
|
6694
|
+
/**
|
|
6695
|
+
* Limit for requests memory in namespace (string)
|
|
6696
|
+
*/
|
|
5143
6697
|
requestsMemory?: pulumi.Input<string>;
|
|
6698
|
+
/**
|
|
6699
|
+
* Limit for requests storage in namespace (string)
|
|
6700
|
+
*/
|
|
5144
6701
|
requestsStorage?: pulumi.Input<string>;
|
|
6702
|
+
/**
|
|
6703
|
+
* Limit for secrets in namespace (string)
|
|
6704
|
+
*/
|
|
5145
6705
|
secrets?: pulumi.Input<string>;
|
|
5146
6706
|
services?: pulumi.Input<string>;
|
|
6707
|
+
/**
|
|
6708
|
+
* Limit for services load balancers in namespace (string)
|
|
6709
|
+
*/
|
|
5147
6710
|
servicesLoadBalancers?: pulumi.Input<string>;
|
|
6711
|
+
/**
|
|
6712
|
+
* Limit for services node ports in namespace (string)
|
|
6713
|
+
*
|
|
6714
|
+
* More info at [resource-quotas](https://rancher.com/docs/rancher/v2.x/en/k8s-in-rancher/projects-and-namespaces/resource-quotas/)
|
|
6715
|
+
*/
|
|
5148
6716
|
servicesNodePorts?: pulumi.Input<string>;
|
|
5149
6717
|
}
|
|
5150
6718
|
export interface NodePoolNodeTaint {
|
|
6719
|
+
/**
|
|
6720
|
+
* Taint effect. Supported values : `"NoExecute" | "NoSchedule" | "PreferNoSchedule"` (string)
|
|
6721
|
+
*/
|
|
5151
6722
|
effect?: pulumi.Input<string>;
|
|
6723
|
+
/**
|
|
6724
|
+
* Taint key (string)
|
|
6725
|
+
*/
|
|
5152
6726
|
key: pulumi.Input<string>;
|
|
6727
|
+
/**
|
|
6728
|
+
* Taint time added (string)
|
|
6729
|
+
*/
|
|
5153
6730
|
timeAdded?: pulumi.Input<string>;
|
|
6731
|
+
/**
|
|
6732
|
+
* Taint value (string)
|
|
6733
|
+
*/
|
|
5154
6734
|
value: pulumi.Input<string>;
|
|
5155
6735
|
}
|
|
5156
6736
|
export interface NodeTemplateAmazonec2Config {
|
|
@@ -5658,70 +7238,261 @@ export interface NodeTemplateLinodeConfig {
|
|
|
5658
7238
|
uaPrefix?: pulumi.Input<string>;
|
|
5659
7239
|
}
|
|
5660
7240
|
export interface NodeTemplateNodeTaint {
|
|
7241
|
+
/**
|
|
7242
|
+
* Taint effect. Supported values : `"NoExecute" | "NoSchedule" | "PreferNoSchedule"` (string)
|
|
7243
|
+
*/
|
|
5661
7244
|
effect?: pulumi.Input<string>;
|
|
7245
|
+
/**
|
|
7246
|
+
* Taint key (string)
|
|
7247
|
+
*/
|
|
5662
7248
|
key: pulumi.Input<string>;
|
|
7249
|
+
/**
|
|
7250
|
+
* Taint time added (string)
|
|
7251
|
+
*/
|
|
5663
7252
|
timeAdded?: pulumi.Input<string>;
|
|
7253
|
+
/**
|
|
7254
|
+
* Taint value (string)
|
|
7255
|
+
*/
|
|
5664
7256
|
value: pulumi.Input<string>;
|
|
5665
7257
|
}
|
|
5666
7258
|
export interface NodeTemplateOpennebulaConfig {
|
|
7259
|
+
/**
|
|
7260
|
+
* Size of the Volatile disk in MB - only for b2d (string)
|
|
7261
|
+
*/
|
|
5667
7262
|
b2dSize?: pulumi.Input<string>;
|
|
7263
|
+
/**
|
|
7264
|
+
* CPU value for the VM (string)
|
|
7265
|
+
*/
|
|
5668
7266
|
cpu?: pulumi.Input<string>;
|
|
7267
|
+
/**
|
|
7268
|
+
* Dev prefix to use for the images. E.g.: 'vd', 'sd', 'hd' (string)
|
|
7269
|
+
*/
|
|
5669
7270
|
devPrefix?: pulumi.Input<string>;
|
|
7271
|
+
/**
|
|
7272
|
+
* VNC is enabled by default. Disable it with this flag (bool)
|
|
7273
|
+
*/
|
|
5670
7274
|
disableVnc?: pulumi.Input<boolean>;
|
|
7275
|
+
/**
|
|
7276
|
+
* Size of the disk for the VM in MB (string)
|
|
7277
|
+
*/
|
|
5671
7278
|
diskResize?: pulumi.Input<string>;
|
|
7279
|
+
/**
|
|
7280
|
+
* OpenStack image id to use for the instance. Conflicts with `imageName` (string)
|
|
7281
|
+
*/
|
|
5672
7282
|
imageId?: pulumi.Input<string>;
|
|
7283
|
+
/**
|
|
7284
|
+
* OpenStack image name to use for the instance. Conflicts with `imageId` (string)
|
|
7285
|
+
*/
|
|
5673
7286
|
imageName?: pulumi.Input<string>;
|
|
7287
|
+
/**
|
|
7288
|
+
* Owner of the image to use as the VM OS (string)
|
|
7289
|
+
*/
|
|
5674
7290
|
imageOwner?: pulumi.Input<string>;
|
|
7291
|
+
/**
|
|
7292
|
+
* Size of the memory for the VM in MB (string)
|
|
7293
|
+
*/
|
|
5675
7294
|
memory?: pulumi.Input<string>;
|
|
7295
|
+
/**
|
|
7296
|
+
* Opennebula network ID to connect the machine to. Conflicts with `networkName` (string)
|
|
7297
|
+
*/
|
|
5676
7298
|
networkId?: pulumi.Input<string>;
|
|
7299
|
+
/**
|
|
7300
|
+
* Opennebula network to connect the machine to. Conflicts with `networkId` (string)
|
|
7301
|
+
*/
|
|
5677
7302
|
networkName?: pulumi.Input<string>;
|
|
7303
|
+
/**
|
|
7304
|
+
* Opennebula user ID of the Network to connect the machine to (string)
|
|
7305
|
+
*/
|
|
5678
7306
|
networkOwner?: pulumi.Input<string>;
|
|
7307
|
+
/**
|
|
7308
|
+
* vSphere password. Mandatory on Rancher v2.0.x and v2.1.x. Use `rancher2.CloudCredential` from Rancher v2.2.x (string)
|
|
7309
|
+
*/
|
|
5679
7310
|
password: pulumi.Input<string>;
|
|
7311
|
+
/**
|
|
7312
|
+
* If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
|
|
7313
|
+
*/
|
|
5680
7314
|
sshUser?: pulumi.Input<string>;
|
|
7315
|
+
/**
|
|
7316
|
+
* Opennebula template ID to use. Conflicts with `templateName` (string)
|
|
7317
|
+
*/
|
|
5681
7318
|
templateId?: pulumi.Input<string>;
|
|
7319
|
+
/**
|
|
7320
|
+
* Name of the Opennbula template to use. Conflicts with `templateId` (string)
|
|
7321
|
+
*/
|
|
5682
7322
|
templateName?: pulumi.Input<string>;
|
|
7323
|
+
/**
|
|
7324
|
+
* Set the user for the XML-RPC API authentication (string)
|
|
7325
|
+
*/
|
|
5683
7326
|
user: pulumi.Input<string>;
|
|
7327
|
+
/**
|
|
7328
|
+
* VCPUs for the VM (string)
|
|
7329
|
+
*
|
|
7330
|
+
* > **Note:**: `Required*` denotes that one of imageName / imageId or templateName / templateId is required but you cannot combine them.
|
|
7331
|
+
*/
|
|
5684
7332
|
vcpu?: pulumi.Input<string>;
|
|
7333
|
+
/**
|
|
7334
|
+
* Set the url for the Opennebula XML-RPC API (string)
|
|
7335
|
+
*/
|
|
5685
7336
|
xmlRpcUrl: pulumi.Input<string>;
|
|
5686
7337
|
}
|
|
5687
7338
|
export interface NodeTemplateOpenstackConfig {
|
|
7339
|
+
/**
|
|
7340
|
+
* OpenStack active timeout Default `200` (string)
|
|
7341
|
+
*/
|
|
5688
7342
|
activeTimeout?: pulumi.Input<string>;
|
|
7343
|
+
/**
|
|
7344
|
+
* OpenStack application credential id. Conflicts with `applicationCredentialName` (string)
|
|
7345
|
+
*/
|
|
5689
7346
|
applicationCredentialId?: pulumi.Input<string>;
|
|
7347
|
+
/**
|
|
7348
|
+
* OpenStack application credential name. Conflicts with `applicationCredentialId` (string)
|
|
7349
|
+
*/
|
|
5690
7350
|
applicationCredentialName?: pulumi.Input<string>;
|
|
7351
|
+
/**
|
|
7352
|
+
* OpenStack application credential secret (string)
|
|
7353
|
+
*/
|
|
5691
7354
|
applicationCredentialSecret?: pulumi.Input<string>;
|
|
7355
|
+
/**
|
|
7356
|
+
* OpenStack authentication URL (string)
|
|
7357
|
+
*/
|
|
5692
7358
|
authUrl: pulumi.Input<string>;
|
|
7359
|
+
/**
|
|
7360
|
+
* OpenStack availability zone (string)
|
|
7361
|
+
*/
|
|
5693
7362
|
availabilityZone: pulumi.Input<string>;
|
|
7363
|
+
/**
|
|
7364
|
+
* Enable booting from volume. Default is `false` (bool)
|
|
7365
|
+
*/
|
|
5694
7366
|
bootFromVolume?: pulumi.Input<boolean>;
|
|
7367
|
+
/**
|
|
7368
|
+
* CA certificate bundle to verify against (string)
|
|
7369
|
+
*/
|
|
5695
7370
|
cacert?: pulumi.Input<string>;
|
|
7371
|
+
/**
|
|
7372
|
+
* Enables the OpenStack config drive for the instance. Default `false` (bool)
|
|
7373
|
+
*/
|
|
5696
7374
|
configDrive?: pulumi.Input<boolean>;
|
|
7375
|
+
/**
|
|
7376
|
+
* OpenStack domain ID. Identity v3 only. Conflicts with `domainName` (string)
|
|
7377
|
+
*/
|
|
5697
7378
|
domainId?: pulumi.Input<string>;
|
|
7379
|
+
/**
|
|
7380
|
+
* OpenStack domain name. Identity v3 only. Conflicts with `domainId` (string)
|
|
7381
|
+
*/
|
|
5698
7382
|
domainName?: pulumi.Input<string>;
|
|
7383
|
+
/**
|
|
7384
|
+
* OpenStack endpoint type. adminURL, internalURL or publicURL (string)
|
|
7385
|
+
*/
|
|
5699
7386
|
endpointType?: pulumi.Input<string>;
|
|
7387
|
+
/**
|
|
7388
|
+
* OpenStack flavor id to use for the instance. Conflicts with `flavorName` (string)
|
|
7389
|
+
*/
|
|
5700
7390
|
flavorId?: pulumi.Input<string>;
|
|
7391
|
+
/**
|
|
7392
|
+
* OpenStack flavor name to use for the instance. Conflicts with `flavorId` (string)
|
|
7393
|
+
*/
|
|
5701
7394
|
flavorName?: pulumi.Input<string>;
|
|
7395
|
+
/**
|
|
7396
|
+
* OpenStack floating IP pool to get an IP from to assign to the instance (string)
|
|
7397
|
+
*/
|
|
5702
7398
|
floatingIpPool?: pulumi.Input<string>;
|
|
7399
|
+
/**
|
|
7400
|
+
* OpenStack image id to use for the instance. Conflicts with `imageName` (string)
|
|
7401
|
+
*/
|
|
5703
7402
|
imageId?: pulumi.Input<string>;
|
|
7403
|
+
/**
|
|
7404
|
+
* OpenStack image name to use for the instance. Conflicts with `imageId` (string)
|
|
7405
|
+
*/
|
|
5704
7406
|
imageName?: pulumi.Input<string>;
|
|
7407
|
+
/**
|
|
7408
|
+
* Disable TLS credential checking. Default `false` (bool)
|
|
7409
|
+
*/
|
|
5705
7410
|
insecure?: pulumi.Input<boolean>;
|
|
7411
|
+
/**
|
|
7412
|
+
* OpenStack version of IP address assigned for the machine Default `4` (string)
|
|
7413
|
+
*/
|
|
5706
7414
|
ipVersion?: pulumi.Input<string>;
|
|
7415
|
+
/**
|
|
7416
|
+
* OpenStack keypair to use to SSH to the instance (string)
|
|
7417
|
+
*/
|
|
5707
7418
|
keypairName?: pulumi.Input<string>;
|
|
7419
|
+
/**
|
|
7420
|
+
* OpenStack network id the machine will be connected on. Conflicts with `netName` (string)
|
|
7421
|
+
*/
|
|
5708
7422
|
netId?: pulumi.Input<string>;
|
|
7423
|
+
/**
|
|
7424
|
+
* OpenStack network name the machine will be connected on. Conflicts with `netId` (string)
|
|
7425
|
+
*/
|
|
5709
7426
|
netName?: pulumi.Input<string>;
|
|
7427
|
+
/**
|
|
7428
|
+
* Use the nova networking services instead of neutron (string)
|
|
7429
|
+
*/
|
|
5710
7430
|
novaNetwork?: pulumi.Input<boolean>;
|
|
7431
|
+
/**
|
|
7432
|
+
* vSphere password. Mandatory on Rancher v2.0.x and v2.1.x. Use `rancher2.CloudCredential` from Rancher v2.2.x (string)
|
|
7433
|
+
*/
|
|
5711
7434
|
password?: pulumi.Input<string>;
|
|
7435
|
+
/**
|
|
7436
|
+
* Private key content to use for SSH (string)
|
|
7437
|
+
*/
|
|
5712
7438
|
privateKeyFile?: pulumi.Input<string>;
|
|
7439
|
+
/**
|
|
7440
|
+
* AWS region. Default `eu-west-2` (string)
|
|
7441
|
+
*/
|
|
5713
7442
|
region: pulumi.Input<string>;
|
|
7443
|
+
/**
|
|
7444
|
+
* OpenStack comma separated security groups for the machine (string)
|
|
7445
|
+
*/
|
|
5714
7446
|
secGroups?: pulumi.Input<string>;
|
|
7447
|
+
/**
|
|
7448
|
+
* If using a non-B2D image you can specify the ssh port. Default `22`. From Rancher v2.3.3 (string)
|
|
7449
|
+
*/
|
|
5715
7450
|
sshPort?: pulumi.Input<string>;
|
|
7451
|
+
/**
|
|
7452
|
+
* If using a non-B2D image you can specify the ssh user. Default `docker`. From Rancher v2.3.3 (string)
|
|
7453
|
+
*/
|
|
5716
7454
|
sshUser?: pulumi.Input<string>;
|
|
7455
|
+
/**
|
|
7456
|
+
* OpenStack tenant id. Conflicts with `tenantName` (string)
|
|
7457
|
+
*/
|
|
5717
7458
|
tenantId?: pulumi.Input<string>;
|
|
7459
|
+
/**
|
|
7460
|
+
* OpenStack tenant name. Conflicts with `tenantId` (string)
|
|
7461
|
+
*/
|
|
5718
7462
|
tenantName?: pulumi.Input<string>;
|
|
7463
|
+
/**
|
|
7464
|
+
* File containing an openstack userdata script (string)
|
|
7465
|
+
*/
|
|
5719
7466
|
userDataFile?: pulumi.Input<string>;
|
|
7467
|
+
/**
|
|
7468
|
+
* vSphere username. Mandatory on Rancher v2.0.x and v2.1.x. Use `rancher2.CloudCredential` from Rancher v2.2.x (string)
|
|
7469
|
+
*/
|
|
5720
7470
|
username?: pulumi.Input<string>;
|
|
7471
|
+
/**
|
|
7472
|
+
* OpenStack volume device path (attaching). Applicable only when `bootFromVolume` is `true`. Omit for auto `/dev/vdb`. (string)
|
|
7473
|
+
*
|
|
7474
|
+
* > **Note:**: `Required*` denotes that either the _name or _id is required but you cannot use both.
|
|
7475
|
+
*
|
|
7476
|
+
* > **Note:**: `Required**` denotes that either the _name or _id is required unless `applicationCredentialId` is defined.
|
|
7477
|
+
*
|
|
7478
|
+
* > **Note for OpenStack users:**: `keypairName` is required to be in the schema even if there are no references in rancher itself
|
|
7479
|
+
*/
|
|
5721
7480
|
volumeDevicePath?: pulumi.Input<string>;
|
|
7481
|
+
/**
|
|
7482
|
+
* OpenStack volume id of existing volume. Applicable only when `bootFromVolume` is `true` (string)
|
|
7483
|
+
*/
|
|
5722
7484
|
volumeId?: pulumi.Input<string>;
|
|
7485
|
+
/**
|
|
7486
|
+
* OpenStack volume name of existing volume. Applicable only when `bootFromVolume` is `true` (string)
|
|
7487
|
+
*/
|
|
5723
7488
|
volumeName?: pulumi.Input<string>;
|
|
7489
|
+
/**
|
|
7490
|
+
* OpenStack volume size (GiB). Required when `bootFromVolume` is `true` (string)
|
|
7491
|
+
*/
|
|
5724
7492
|
volumeSize?: pulumi.Input<string>;
|
|
7493
|
+
/**
|
|
7494
|
+
* OpenStack volume type. Required when `bootFromVolume` is `true` and openstack cloud does not have a default volume type (string)
|
|
7495
|
+
*/
|
|
5725
7496
|
volumeType?: pulumi.Input<string>;
|
|
5726
7497
|
}
|
|
5727
7498
|
export interface NodeTemplateOutscaleConfig {
|
|
@@ -6279,9 +8050,21 @@ export interface ProjectAlertRuleWorkloadRule {
|
|
|
6279
8050
|
workloadId?: pulumi.Input<string>;
|
|
6280
8051
|
}
|
|
6281
8052
|
export interface ProjectContainerResourceLimit {
|
|
8053
|
+
/**
|
|
8054
|
+
* Limit for limits cpu in project (string)
|
|
8055
|
+
*/
|
|
6282
8056
|
limitsCpu?: pulumi.Input<string>;
|
|
8057
|
+
/**
|
|
8058
|
+
* Limit for limits memory in project (string)
|
|
8059
|
+
*/
|
|
6283
8060
|
limitsMemory?: pulumi.Input<string>;
|
|
8061
|
+
/**
|
|
8062
|
+
* Limit for requests cpu in project (string)
|
|
8063
|
+
*/
|
|
6284
8064
|
requestsCpu?: pulumi.Input<string>;
|
|
8065
|
+
/**
|
|
8066
|
+
* Limit for requests memory in project (string)
|
|
8067
|
+
*/
|
|
6285
8068
|
requestsMemory?: pulumi.Input<string>;
|
|
6286
8069
|
}
|
|
6287
8070
|
export interface ProjectProjectMonitoringInput {
|
|
@@ -6297,42 +8080,133 @@ export interface ProjectProjectMonitoringInput {
|
|
|
6297
8080
|
version?: pulumi.Input<string>;
|
|
6298
8081
|
}
|
|
6299
8082
|
export interface ProjectResourceQuota {
|
|
8083
|
+
/**
|
|
8084
|
+
* Default resource quota limit for namespaces in project (list maxitems:1)
|
|
8085
|
+
*/
|
|
6300
8086
|
namespaceDefaultLimit: pulumi.Input<inputs.ProjectResourceQuotaNamespaceDefaultLimit>;
|
|
8087
|
+
/**
|
|
8088
|
+
* Resource quota limit for project (list maxitems:1)
|
|
8089
|
+
*/
|
|
6301
8090
|
projectLimit: pulumi.Input<inputs.ProjectResourceQuotaProjectLimit>;
|
|
6302
8091
|
}
|
|
6303
8092
|
export interface ProjectResourceQuotaNamespaceDefaultLimit {
|
|
8093
|
+
/**
|
|
8094
|
+
* Limit for config maps in project (string)
|
|
8095
|
+
*/
|
|
6304
8096
|
configMaps?: pulumi.Input<string>;
|
|
8097
|
+
/**
|
|
8098
|
+
* Limit for limits cpu in project (string)
|
|
8099
|
+
*/
|
|
6305
8100
|
limitsCpu?: pulumi.Input<string>;
|
|
8101
|
+
/**
|
|
8102
|
+
* Limit for limits memory in project (string)
|
|
8103
|
+
*/
|
|
6306
8104
|
limitsMemory?: pulumi.Input<string>;
|
|
8105
|
+
/**
|
|
8106
|
+
* Limit for persistent volume claims in project (string)
|
|
8107
|
+
*/
|
|
6307
8108
|
persistentVolumeClaims?: pulumi.Input<string>;
|
|
8109
|
+
/**
|
|
8110
|
+
* Limit for pods in project (string)
|
|
8111
|
+
*/
|
|
6308
8112
|
pods?: pulumi.Input<string>;
|
|
8113
|
+
/**
|
|
8114
|
+
* Limit for replication controllers in project (string)
|
|
8115
|
+
*/
|
|
6309
8116
|
replicationControllers?: pulumi.Input<string>;
|
|
8117
|
+
/**
|
|
8118
|
+
* Limit for requests cpu in project (string)
|
|
8119
|
+
*/
|
|
6310
8120
|
requestsCpu?: pulumi.Input<string>;
|
|
8121
|
+
/**
|
|
8122
|
+
* Limit for requests memory in project (string)
|
|
8123
|
+
*/
|
|
6311
8124
|
requestsMemory?: pulumi.Input<string>;
|
|
8125
|
+
/**
|
|
8126
|
+
* Limit for requests storage in project (string)
|
|
8127
|
+
*/
|
|
6312
8128
|
requestsStorage?: pulumi.Input<string>;
|
|
8129
|
+
/**
|
|
8130
|
+
* Limit for secrets in project (string)
|
|
8131
|
+
*/
|
|
6313
8132
|
secrets?: pulumi.Input<string>;
|
|
6314
8133
|
services?: pulumi.Input<string>;
|
|
8134
|
+
/**
|
|
8135
|
+
* Limit for services load balancers in project (string)
|
|
8136
|
+
*/
|
|
6315
8137
|
servicesLoadBalancers?: pulumi.Input<string>;
|
|
8138
|
+
/**
|
|
8139
|
+
* Limit for services node ports in project (string)
|
|
8140
|
+
*
|
|
8141
|
+
* More info at [resource-quotas](https://rancher.com/docs/rancher/v2.x/en/k8s-in-rancher/projects-and-namespaces/resource-quotas/)
|
|
8142
|
+
*/
|
|
6316
8143
|
servicesNodePorts?: pulumi.Input<string>;
|
|
6317
8144
|
}
|
|
6318
8145
|
export interface ProjectResourceQuotaProjectLimit {
|
|
8146
|
+
/**
|
|
8147
|
+
* Limit for config maps in project (string)
|
|
8148
|
+
*/
|
|
6319
8149
|
configMaps?: pulumi.Input<string>;
|
|
8150
|
+
/**
|
|
8151
|
+
* Limit for limits cpu in project (string)
|
|
8152
|
+
*/
|
|
6320
8153
|
limitsCpu?: pulumi.Input<string>;
|
|
8154
|
+
/**
|
|
8155
|
+
* Limit for limits memory in project (string)
|
|
8156
|
+
*/
|
|
6321
8157
|
limitsMemory?: pulumi.Input<string>;
|
|
8158
|
+
/**
|
|
8159
|
+
* Limit for persistent volume claims in project (string)
|
|
8160
|
+
*/
|
|
6322
8161
|
persistentVolumeClaims?: pulumi.Input<string>;
|
|
8162
|
+
/**
|
|
8163
|
+
* Limit for pods in project (string)
|
|
8164
|
+
*/
|
|
6323
8165
|
pods?: pulumi.Input<string>;
|
|
8166
|
+
/**
|
|
8167
|
+
* Limit for replication controllers in project (string)
|
|
8168
|
+
*/
|
|
6324
8169
|
replicationControllers?: pulumi.Input<string>;
|
|
8170
|
+
/**
|
|
8171
|
+
* Limit for requests cpu in project (string)
|
|
8172
|
+
*/
|
|
6325
8173
|
requestsCpu?: pulumi.Input<string>;
|
|
8174
|
+
/**
|
|
8175
|
+
* Limit for requests memory in project (string)
|
|
8176
|
+
*/
|
|
6326
8177
|
requestsMemory?: pulumi.Input<string>;
|
|
8178
|
+
/**
|
|
8179
|
+
* Limit for requests storage in project (string)
|
|
8180
|
+
*/
|
|
6327
8181
|
requestsStorage?: pulumi.Input<string>;
|
|
8182
|
+
/**
|
|
8183
|
+
* Limit for secrets in project (string)
|
|
8184
|
+
*/
|
|
6328
8185
|
secrets?: pulumi.Input<string>;
|
|
6329
8186
|
services?: pulumi.Input<string>;
|
|
8187
|
+
/**
|
|
8188
|
+
* Limit for services load balancers in project (string)
|
|
8189
|
+
*/
|
|
6330
8190
|
servicesLoadBalancers?: pulumi.Input<string>;
|
|
8191
|
+
/**
|
|
8192
|
+
* Limit for services node ports in project (string)
|
|
8193
|
+
*
|
|
8194
|
+
* More info at [resource-quotas](https://rancher.com/docs/rancher/v2.x/en/k8s-in-rancher/projects-and-namespaces/resource-quotas/)
|
|
8195
|
+
*/
|
|
6331
8196
|
servicesNodePorts?: pulumi.Input<string>;
|
|
6332
8197
|
}
|
|
6333
8198
|
export interface RegistryRegistry {
|
|
8199
|
+
/**
|
|
8200
|
+
* Address for registry.
|
|
8201
|
+
*/
|
|
6334
8202
|
address: pulumi.Input<string>;
|
|
8203
|
+
/**
|
|
8204
|
+
* Password for the registry (string)
|
|
8205
|
+
*/
|
|
6335
8206
|
password?: pulumi.Input<string>;
|
|
8207
|
+
/**
|
|
8208
|
+
* Username for the registry (string)
|
|
8209
|
+
*/
|
|
6336
8210
|
username?: pulumi.Input<string>;
|
|
6337
8211
|
}
|
|
6338
8212
|
export interface RoleTemplateExternalRule {
|