google_cloud_container_v1/client.rs
1// Copyright 2025 Google LLC
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// https://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14//
15// Code generated by sidekick. DO NOT EDIT.
16#![allow(rustdoc::bare_urls)]
17#![allow(rustdoc::broken_intra_doc_links)]
18#![allow(rustdoc::invalid_html_tags)]
19#![allow(rustdoc::redundant_explicit_links)]
20
21/// Implements a client for the Kubernetes Engine API.
22///
23/// # Example
24/// ```
25/// # use google_cloud_container_v1::client::ClusterManager;
26/// async fn sample(
27/// ) -> anyhow::Result<()> {
28/// let client = ClusterManager::builder().build().await?;
29/// let response = client.list_clusters()
30/// /* set fields */
31/// .send().await?;
32/// println!("response {:?}", response);
33/// Ok(())
34/// }
35/// ```
36///
37/// # Service Description
38///
39/// Google Kubernetes Engine Cluster Manager v1
40///
41/// # Configuration
42///
43/// To configure `ClusterManager` use the `with_*` methods in the type returned
44/// by [builder()][ClusterManager::builder]. The default configuration should
45/// work for most applications. Common configuration changes include
46///
47/// * [with_endpoint()]: by default this client uses the global default endpoint
48/// (`https://container.googleapis.com`). Applications using regional
49/// endpoints or running in restricted networks (e.g. a network configured
50/// with [Private Google Access with VPC Service Controls]) may want to
51/// override this default.
52/// * [with_credentials()]: by default this client uses
53/// [Application Default Credentials]. Applications using custom
54/// authentication may need to override this default.
55///
56/// [with_endpoint()]: super::builder::cluster_manager::ClientBuilder::with_endpoint
57/// [with_credentials()]: super::builder::cluster_manager::ClientBuilder::with_credentials
58/// [Private Google Access with VPC Service Controls]: https://cloud.google.com/vpc-service-controls/docs/private-connectivity
59/// [Application Default Credentials]: https://cloud.google.com/docs/authentication#adc
60///
61/// # Pooling and Cloning
62///
63/// `ClusterManager` holds a connection pool internally, it is advised to
64/// create one and reuse it. You do not need to wrap `ClusterManager` in
65/// an [Rc](std::rc::Rc) or [Arc](std::sync::Arc) to reuse it, because it
66/// already uses an `Arc` internally.
67#[derive(Clone, Debug)]
68pub struct ClusterManager {
69 inner: std::sync::Arc<dyn super::stub::dynamic::ClusterManager>,
70}
71
72impl ClusterManager {
73 /// Returns a builder for [ClusterManager].
74 ///
75 /// ```
76 /// # async fn sample() -> google_cloud_gax::client_builder::Result<()> {
77 /// # use google_cloud_container_v1::client::ClusterManager;
78 /// let client = ClusterManager::builder().build().await?;
79 /// # Ok(()) }
80 /// ```
81 pub fn builder() -> super::builder::cluster_manager::ClientBuilder {
82 crate::new_client_builder(super::builder::cluster_manager::client::Factory)
83 }
84
85 /// Creates a new client from the provided stub.
86 ///
87 /// The most common case for calling this function is in tests mocking the
88 /// client's behavior.
89 pub fn from_stub<T>(stub: impl Into<std::sync::Arc<T>>) -> Self
90 where
91 T: super::stub::ClusterManager + 'static,
92 {
93 Self { inner: stub.into() }
94 }
95
96 pub(crate) async fn new(
97 config: gaxi::options::ClientConfig,
98 ) -> crate::ClientBuilderResult<Self> {
99 let inner = Self::build_inner(config).await?;
100 Ok(Self { inner })
101 }
102
103 async fn build_inner(
104 conf: gaxi::options::ClientConfig,
105 ) -> crate::ClientBuilderResult<std::sync::Arc<dyn super::stub::dynamic::ClusterManager>> {
106 if gaxi::options::tracing_enabled(&conf) {
107 return Ok(std::sync::Arc::new(Self::build_with_tracing(conf).await?));
108 }
109 Ok(std::sync::Arc::new(Self::build_transport(conf).await?))
110 }
111
112 async fn build_transport(
113 conf: gaxi::options::ClientConfig,
114 ) -> crate::ClientBuilderResult<impl super::stub::ClusterManager> {
115 super::transport::ClusterManager::new(conf).await
116 }
117
118 async fn build_with_tracing(
119 conf: gaxi::options::ClientConfig,
120 ) -> crate::ClientBuilderResult<impl super::stub::ClusterManager> {
121 Self::build_transport(conf)
122 .await
123 .map(super::tracing::ClusterManager::new)
124 }
125
126 /// Lists all clusters owned by a project in either the specified zone or all
127 /// zones.
128 ///
129 /// # Example
130 /// ```
131 /// # use google_cloud_container_v1::client::ClusterManager;
132 /// use google_cloud_container_v1::Result;
133 /// async fn sample(
134 /// client: &ClusterManager
135 /// ) -> Result<()> {
136 /// let response = client.list_clusters()
137 /// /* set fields */
138 /// .send().await?;
139 /// println!("response {:?}", response);
140 /// Ok(())
141 /// }
142 /// ```
143 pub fn list_clusters(&self) -> super::builder::cluster_manager::ListClusters {
144 super::builder::cluster_manager::ListClusters::new(self.inner.clone())
145 }
146
147 /// Gets the details of a specific cluster.
148 ///
149 /// # Example
150 /// ```
151 /// # use google_cloud_container_v1::client::ClusterManager;
152 /// use google_cloud_container_v1::Result;
153 /// async fn sample(
154 /// client: &ClusterManager
155 /// ) -> Result<()> {
156 /// let response = client.get_cluster()
157 /// /* set fields */
158 /// .send().await?;
159 /// println!("response {:?}", response);
160 /// Ok(())
161 /// }
162 /// ```
163 pub fn get_cluster(&self) -> super::builder::cluster_manager::GetCluster {
164 super::builder::cluster_manager::GetCluster::new(self.inner.clone())
165 }
166
167 /// Creates a cluster, consisting of the specified number and type of Google
168 /// Compute Engine instances.
169 ///
170 /// By default, the cluster is created in the project's
171 /// [default
172 /// network](https://cloud.google.com/compute/docs/networks-and-firewalls#networks).
173 ///
174 /// One firewall is added for the cluster. After cluster creation,
175 /// the kubelet creates routes for each node to allow the containers
176 /// on that node to communicate with all other instances in the
177 /// cluster.
178 ///
179 /// Finally, an entry is added to the project's global metadata indicating
180 /// which CIDR range the cluster is using.
181 ///
182 /// # Example
183 /// ```
184 /// # use google_cloud_container_v1::client::ClusterManager;
185 /// use google_cloud_container_v1::Result;
186 /// async fn sample(
187 /// client: &ClusterManager
188 /// ) -> Result<()> {
189 /// let response = client.create_cluster()
190 /// /* set fields */
191 /// .send().await?;
192 /// println!("response {:?}", response);
193 /// Ok(())
194 /// }
195 /// ```
196 pub fn create_cluster(&self) -> super::builder::cluster_manager::CreateCluster {
197 super::builder::cluster_manager::CreateCluster::new(self.inner.clone())
198 }
199
200 /// Updates the settings of a specific cluster.
201 ///
202 /// # Example
203 /// ```
204 /// # use google_cloud_container_v1::client::ClusterManager;
205 /// use google_cloud_container_v1::Result;
206 /// async fn sample(
207 /// client: &ClusterManager
208 /// ) -> Result<()> {
209 /// let response = client.update_cluster()
210 /// /* set fields */
211 /// .send().await?;
212 /// println!("response {:?}", response);
213 /// Ok(())
214 /// }
215 /// ```
216 pub fn update_cluster(&self) -> super::builder::cluster_manager::UpdateCluster {
217 super::builder::cluster_manager::UpdateCluster::new(self.inner.clone())
218 }
219
220 /// Updates the version and/or image type for the specified node pool.
221 ///
222 /// # Example
223 /// ```
224 /// # use google_cloud_container_v1::client::ClusterManager;
225 /// use google_cloud_container_v1::Result;
226 /// async fn sample(
227 /// client: &ClusterManager
228 /// ) -> Result<()> {
229 /// let response = client.update_node_pool()
230 /// /* set fields */
231 /// .send().await?;
232 /// println!("response {:?}", response);
233 /// Ok(())
234 /// }
235 /// ```
236 pub fn update_node_pool(&self) -> super::builder::cluster_manager::UpdateNodePool {
237 super::builder::cluster_manager::UpdateNodePool::new(self.inner.clone())
238 }
239
240 /// Sets the autoscaling settings for the specified node pool.
241 ///
242 /// # Example
243 /// ```
244 /// # use google_cloud_container_v1::client::ClusterManager;
245 /// use google_cloud_container_v1::Result;
246 /// async fn sample(
247 /// client: &ClusterManager
248 /// ) -> Result<()> {
249 /// let response = client.set_node_pool_autoscaling()
250 /// /* set fields */
251 /// .send().await?;
252 /// println!("response {:?}", response);
253 /// Ok(())
254 /// }
255 /// ```
256 pub fn set_node_pool_autoscaling(
257 &self,
258 ) -> super::builder::cluster_manager::SetNodePoolAutoscaling {
259 super::builder::cluster_manager::SetNodePoolAutoscaling::new(self.inner.clone())
260 }
261
262 /// Sets the logging service for a specific cluster.
263 ///
264 /// # Example
265 /// ```
266 /// # use google_cloud_container_v1::client::ClusterManager;
267 /// use google_cloud_container_v1::Result;
268 /// async fn sample(
269 /// client: &ClusterManager
270 /// ) -> Result<()> {
271 /// let response = client.set_logging_service()
272 /// /* set fields */
273 /// .send().await?;
274 /// println!("response {:?}", response);
275 /// Ok(())
276 /// }
277 /// ```
278 pub fn set_logging_service(&self) -> super::builder::cluster_manager::SetLoggingService {
279 super::builder::cluster_manager::SetLoggingService::new(self.inner.clone())
280 }
281
282 /// Sets the monitoring service for a specific cluster.
283 ///
284 /// # Example
285 /// ```
286 /// # use google_cloud_container_v1::client::ClusterManager;
287 /// use google_cloud_container_v1::Result;
288 /// async fn sample(
289 /// client: &ClusterManager
290 /// ) -> Result<()> {
291 /// let response = client.set_monitoring_service()
292 /// /* set fields */
293 /// .send().await?;
294 /// println!("response {:?}", response);
295 /// Ok(())
296 /// }
297 /// ```
298 pub fn set_monitoring_service(&self) -> super::builder::cluster_manager::SetMonitoringService {
299 super::builder::cluster_manager::SetMonitoringService::new(self.inner.clone())
300 }
301
302 /// Sets the addons for a specific cluster.
303 ///
304 /// # Example
305 /// ```
306 /// # use google_cloud_container_v1::client::ClusterManager;
307 /// use google_cloud_container_v1::Result;
308 /// async fn sample(
309 /// client: &ClusterManager
310 /// ) -> Result<()> {
311 /// let response = client.set_addons_config()
312 /// /* set fields */
313 /// .send().await?;
314 /// println!("response {:?}", response);
315 /// Ok(())
316 /// }
317 /// ```
318 pub fn set_addons_config(&self) -> super::builder::cluster_manager::SetAddonsConfig {
319 super::builder::cluster_manager::SetAddonsConfig::new(self.inner.clone())
320 }
321
322 /// Sets the locations for a specific cluster.
323 /// Deprecated. Use
324 /// [projects.locations.clusters.update](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/projects.locations.clusters/update)
325 /// instead.
326 ///
327 /// # Example
328 /// ```
329 /// # use google_cloud_container_v1::client::ClusterManager;
330 /// use google_cloud_container_v1::Result;
331 /// async fn sample(
332 /// client: &ClusterManager
333 /// ) -> Result<()> {
334 /// let response = client.set_locations()
335 /// /* set fields */
336 /// .send().await?;
337 /// println!("response {:?}", response);
338 /// Ok(())
339 /// }
340 /// ```
341 #[deprecated]
342 pub fn set_locations(&self) -> super::builder::cluster_manager::SetLocations {
343 super::builder::cluster_manager::SetLocations::new(self.inner.clone())
344 }
345
346 /// Updates the master for a specific cluster.
347 ///
348 /// # Example
349 /// ```
350 /// # use google_cloud_container_v1::client::ClusterManager;
351 /// use google_cloud_container_v1::Result;
352 /// async fn sample(
353 /// client: &ClusterManager
354 /// ) -> Result<()> {
355 /// let response = client.update_master()
356 /// /* set fields */
357 /// .send().await?;
358 /// println!("response {:?}", response);
359 /// Ok(())
360 /// }
361 /// ```
362 pub fn update_master(&self) -> super::builder::cluster_manager::UpdateMaster {
363 super::builder::cluster_manager::UpdateMaster::new(self.inner.clone())
364 }
365
366 /// Sets master auth materials. Currently supports changing the admin password
367 /// or a specific cluster, either via password generation or explicitly setting
368 /// the password.
369 ///
370 /// # Example
371 /// ```
372 /// # use google_cloud_container_v1::client::ClusterManager;
373 /// use google_cloud_container_v1::Result;
374 /// async fn sample(
375 /// client: &ClusterManager
376 /// ) -> Result<()> {
377 /// let response = client.set_master_auth()
378 /// /* set fields */
379 /// .send().await?;
380 /// println!("response {:?}", response);
381 /// Ok(())
382 /// }
383 /// ```
384 pub fn set_master_auth(&self) -> super::builder::cluster_manager::SetMasterAuth {
385 super::builder::cluster_manager::SetMasterAuth::new(self.inner.clone())
386 }
387
388 /// Deletes the cluster, including the Kubernetes endpoint and all worker
389 /// nodes.
390 ///
391 /// Firewalls and routes that were configured during cluster creation
392 /// are also deleted.
393 ///
394 /// Other Google Compute Engine resources that might be in use by the cluster,
395 /// such as load balancer resources, are not deleted if they weren't present
396 /// when the cluster was initially created.
397 ///
398 /// # Example
399 /// ```
400 /// # use google_cloud_container_v1::client::ClusterManager;
401 /// use google_cloud_container_v1::Result;
402 /// async fn sample(
403 /// client: &ClusterManager
404 /// ) -> Result<()> {
405 /// let response = client.delete_cluster()
406 /// /* set fields */
407 /// .send().await?;
408 /// println!("response {:?}", response);
409 /// Ok(())
410 /// }
411 /// ```
412 pub fn delete_cluster(&self) -> super::builder::cluster_manager::DeleteCluster {
413 super::builder::cluster_manager::DeleteCluster::new(self.inner.clone())
414 }
415
416 /// Lists all operations in a project in a specific zone or all zones.
417 ///
418 /// # Example
419 /// ```
420 /// # use google_cloud_container_v1::client::ClusterManager;
421 /// use google_cloud_container_v1::Result;
422 /// async fn sample(
423 /// client: &ClusterManager
424 /// ) -> Result<()> {
425 /// let response = client.list_operations()
426 /// /* set fields */
427 /// .send().await?;
428 /// println!("response {:?}", response);
429 /// Ok(())
430 /// }
431 /// ```
432 pub fn list_operations(&self) -> super::builder::cluster_manager::ListOperations {
433 super::builder::cluster_manager::ListOperations::new(self.inner.clone())
434 }
435
436 /// Gets the specified operation.
437 ///
438 /// # Example
439 /// ```
440 /// # use google_cloud_container_v1::client::ClusterManager;
441 /// use google_cloud_container_v1::Result;
442 /// async fn sample(
443 /// client: &ClusterManager
444 /// ) -> Result<()> {
445 /// let response = client.get_operation()
446 /// /* set fields */
447 /// .send().await?;
448 /// println!("response {:?}", response);
449 /// Ok(())
450 /// }
451 /// ```
452 pub fn get_operation(&self) -> super::builder::cluster_manager::GetOperation {
453 super::builder::cluster_manager::GetOperation::new(self.inner.clone())
454 }
455
456 /// Cancels the specified operation.
457 ///
458 /// # Example
459 /// ```
460 /// # use google_cloud_container_v1::client::ClusterManager;
461 /// use google_cloud_container_v1::Result;
462 /// async fn sample(
463 /// client: &ClusterManager
464 /// ) -> Result<()> {
465 /// client.cancel_operation()
466 /// /* set fields */
467 /// .send().await?;
468 /// Ok(())
469 /// }
470 /// ```
471 pub fn cancel_operation(&self) -> super::builder::cluster_manager::CancelOperation {
472 super::builder::cluster_manager::CancelOperation::new(self.inner.clone())
473 }
474
475 /// Returns configuration info about the Google Kubernetes Engine service.
476 ///
477 /// # Example
478 /// ```
479 /// # use google_cloud_container_v1::client::ClusterManager;
480 /// use google_cloud_container_v1::Result;
481 /// async fn sample(
482 /// client: &ClusterManager
483 /// ) -> Result<()> {
484 /// let response = client.get_server_config()
485 /// /* set fields */
486 /// .send().await?;
487 /// println!("response {:?}", response);
488 /// Ok(())
489 /// }
490 /// ```
491 pub fn get_server_config(&self) -> super::builder::cluster_manager::GetServerConfig {
492 super::builder::cluster_manager::GetServerConfig::new(self.inner.clone())
493 }
494
495 /// Gets the public component of the cluster signing keys in
496 /// JSON Web Key format.
497 ///
498 /// # Example
499 /// ```
500 /// # use google_cloud_container_v1::client::ClusterManager;
501 /// use google_cloud_container_v1::Result;
502 /// async fn sample(
503 /// client: &ClusterManager
504 /// ) -> Result<()> {
505 /// let response = client.get_json_web_keys()
506 /// /* set fields */
507 /// .send().await?;
508 /// println!("response {:?}", response);
509 /// Ok(())
510 /// }
511 /// ```
512 pub fn get_json_web_keys(&self) -> super::builder::cluster_manager::GetJSONWebKeys {
513 super::builder::cluster_manager::GetJSONWebKeys::new(self.inner.clone())
514 }
515
516 /// Lists the node pools for a cluster.
517 ///
518 /// # Example
519 /// ```
520 /// # use google_cloud_container_v1::client::ClusterManager;
521 /// use google_cloud_container_v1::Result;
522 /// async fn sample(
523 /// client: &ClusterManager
524 /// ) -> Result<()> {
525 /// let response = client.list_node_pools()
526 /// /* set fields */
527 /// .send().await?;
528 /// println!("response {:?}", response);
529 /// Ok(())
530 /// }
531 /// ```
532 pub fn list_node_pools(&self) -> super::builder::cluster_manager::ListNodePools {
533 super::builder::cluster_manager::ListNodePools::new(self.inner.clone())
534 }
535
536 /// Retrieves the requested node pool.
537 ///
538 /// # Example
539 /// ```
540 /// # use google_cloud_container_v1::client::ClusterManager;
541 /// use google_cloud_container_v1::Result;
542 /// async fn sample(
543 /// client: &ClusterManager
544 /// ) -> Result<()> {
545 /// let response = client.get_node_pool()
546 /// /* set fields */
547 /// .send().await?;
548 /// println!("response {:?}", response);
549 /// Ok(())
550 /// }
551 /// ```
552 pub fn get_node_pool(&self) -> super::builder::cluster_manager::GetNodePool {
553 super::builder::cluster_manager::GetNodePool::new(self.inner.clone())
554 }
555
556 /// Creates a node pool for a cluster.
557 ///
558 /// # Example
559 /// ```
560 /// # use google_cloud_container_v1::client::ClusterManager;
561 /// use google_cloud_container_v1::Result;
562 /// async fn sample(
563 /// client: &ClusterManager
564 /// ) -> Result<()> {
565 /// let response = client.create_node_pool()
566 /// /* set fields */
567 /// .send().await?;
568 /// println!("response {:?}", response);
569 /// Ok(())
570 /// }
571 /// ```
572 pub fn create_node_pool(&self) -> super::builder::cluster_manager::CreateNodePool {
573 super::builder::cluster_manager::CreateNodePool::new(self.inner.clone())
574 }
575
576 /// Deletes a node pool from a cluster.
577 ///
578 /// # Example
579 /// ```
580 /// # use google_cloud_container_v1::client::ClusterManager;
581 /// use google_cloud_container_v1::Result;
582 /// async fn sample(
583 /// client: &ClusterManager
584 /// ) -> Result<()> {
585 /// let response = client.delete_node_pool()
586 /// /* set fields */
587 /// .send().await?;
588 /// println!("response {:?}", response);
589 /// Ok(())
590 /// }
591 /// ```
592 pub fn delete_node_pool(&self) -> super::builder::cluster_manager::DeleteNodePool {
593 super::builder::cluster_manager::DeleteNodePool::new(self.inner.clone())
594 }
595
596 /// CompleteNodePoolUpgrade will signal an on-going node pool upgrade to
597 /// complete.
598 ///
599 /// # Example
600 /// ```
601 /// # use google_cloud_container_v1::client::ClusterManager;
602 /// use google_cloud_container_v1::Result;
603 /// async fn sample(
604 /// client: &ClusterManager
605 /// ) -> Result<()> {
606 /// client.complete_node_pool_upgrade()
607 /// /* set fields */
608 /// .send().await?;
609 /// Ok(())
610 /// }
611 /// ```
612 pub fn complete_node_pool_upgrade(
613 &self,
614 ) -> super::builder::cluster_manager::CompleteNodePoolUpgrade {
615 super::builder::cluster_manager::CompleteNodePoolUpgrade::new(self.inner.clone())
616 }
617
618 /// Rolls back a previously Aborted or Failed NodePool upgrade.
619 /// This makes no changes if the last upgrade successfully completed.
620 ///
621 /// # Example
622 /// ```
623 /// # use google_cloud_container_v1::client::ClusterManager;
624 /// use google_cloud_container_v1::Result;
625 /// async fn sample(
626 /// client: &ClusterManager
627 /// ) -> Result<()> {
628 /// let response = client.rollback_node_pool_upgrade()
629 /// /* set fields */
630 /// .send().await?;
631 /// println!("response {:?}", response);
632 /// Ok(())
633 /// }
634 /// ```
635 pub fn rollback_node_pool_upgrade(
636 &self,
637 ) -> super::builder::cluster_manager::RollbackNodePoolUpgrade {
638 super::builder::cluster_manager::RollbackNodePoolUpgrade::new(self.inner.clone())
639 }
640
641 /// Sets the NodeManagement options for a node pool.
642 ///
643 /// # Example
644 /// ```
645 /// # use google_cloud_container_v1::client::ClusterManager;
646 /// use google_cloud_container_v1::Result;
647 /// async fn sample(
648 /// client: &ClusterManager
649 /// ) -> Result<()> {
650 /// let response = client.set_node_pool_management()
651 /// /* set fields */
652 /// .send().await?;
653 /// println!("response {:?}", response);
654 /// Ok(())
655 /// }
656 /// ```
657 pub fn set_node_pool_management(
658 &self,
659 ) -> super::builder::cluster_manager::SetNodePoolManagement {
660 super::builder::cluster_manager::SetNodePoolManagement::new(self.inner.clone())
661 }
662
663 /// Sets labels on a cluster.
664 ///
665 /// # Example
666 /// ```
667 /// # use google_cloud_container_v1::client::ClusterManager;
668 /// use google_cloud_container_v1::Result;
669 /// async fn sample(
670 /// client: &ClusterManager
671 /// ) -> Result<()> {
672 /// let response = client.set_labels()
673 /// /* set fields */
674 /// .send().await?;
675 /// println!("response {:?}", response);
676 /// Ok(())
677 /// }
678 /// ```
679 pub fn set_labels(&self) -> super::builder::cluster_manager::SetLabels {
680 super::builder::cluster_manager::SetLabels::new(self.inner.clone())
681 }
682
683 /// Enables or disables the ABAC authorization mechanism on a cluster.
684 ///
685 /// # Example
686 /// ```
687 /// # use google_cloud_container_v1::client::ClusterManager;
688 /// use google_cloud_container_v1::Result;
689 /// async fn sample(
690 /// client: &ClusterManager
691 /// ) -> Result<()> {
692 /// let response = client.set_legacy_abac()
693 /// /* set fields */
694 /// .send().await?;
695 /// println!("response {:?}", response);
696 /// Ok(())
697 /// }
698 /// ```
699 pub fn set_legacy_abac(&self) -> super::builder::cluster_manager::SetLegacyAbac {
700 super::builder::cluster_manager::SetLegacyAbac::new(self.inner.clone())
701 }
702
703 /// Starts master IP rotation.
704 ///
705 /// # Example
706 /// ```
707 /// # use google_cloud_container_v1::client::ClusterManager;
708 /// use google_cloud_container_v1::Result;
709 /// async fn sample(
710 /// client: &ClusterManager
711 /// ) -> Result<()> {
712 /// let response = client.start_ip_rotation()
713 /// /* set fields */
714 /// .send().await?;
715 /// println!("response {:?}", response);
716 /// Ok(())
717 /// }
718 /// ```
719 pub fn start_ip_rotation(&self) -> super::builder::cluster_manager::StartIPRotation {
720 super::builder::cluster_manager::StartIPRotation::new(self.inner.clone())
721 }
722
723 /// Completes master IP rotation.
724 ///
725 /// # Example
726 /// ```
727 /// # use google_cloud_container_v1::client::ClusterManager;
728 /// use google_cloud_container_v1::Result;
729 /// async fn sample(
730 /// client: &ClusterManager
731 /// ) -> Result<()> {
732 /// let response = client.complete_ip_rotation()
733 /// /* set fields */
734 /// .send().await?;
735 /// println!("response {:?}", response);
736 /// Ok(())
737 /// }
738 /// ```
739 pub fn complete_ip_rotation(&self) -> super::builder::cluster_manager::CompleteIPRotation {
740 super::builder::cluster_manager::CompleteIPRotation::new(self.inner.clone())
741 }
742
743 /// Sets the size for a specific node pool. The new size will be used for all
744 /// replicas, including future replicas created by modifying
745 /// [NodePool.locations][google.container.v1.NodePool.locations].
746 ///
747 /// [google.container.v1.NodePool.locations]: crate::model::NodePool::locations
748 ///
749 /// # Example
750 /// ```
751 /// # use google_cloud_container_v1::client::ClusterManager;
752 /// use google_cloud_container_v1::Result;
753 /// async fn sample(
754 /// client: &ClusterManager
755 /// ) -> Result<()> {
756 /// let response = client.set_node_pool_size()
757 /// /* set fields */
758 /// .send().await?;
759 /// println!("response {:?}", response);
760 /// Ok(())
761 /// }
762 /// ```
763 pub fn set_node_pool_size(&self) -> super::builder::cluster_manager::SetNodePoolSize {
764 super::builder::cluster_manager::SetNodePoolSize::new(self.inner.clone())
765 }
766
767 /// Enables or disables Network Policy for a cluster.
768 ///
769 /// # Example
770 /// ```
771 /// # use google_cloud_container_v1::client::ClusterManager;
772 /// use google_cloud_container_v1::Result;
773 /// async fn sample(
774 /// client: &ClusterManager
775 /// ) -> Result<()> {
776 /// let response = client.set_network_policy()
777 /// /* set fields */
778 /// .send().await?;
779 /// println!("response {:?}", response);
780 /// Ok(())
781 /// }
782 /// ```
783 pub fn set_network_policy(&self) -> super::builder::cluster_manager::SetNetworkPolicy {
784 super::builder::cluster_manager::SetNetworkPolicy::new(self.inner.clone())
785 }
786
787 /// Sets the maintenance policy for a cluster.
788 ///
789 /// # Example
790 /// ```
791 /// # use google_cloud_container_v1::client::ClusterManager;
792 /// use google_cloud_container_v1::Result;
793 /// async fn sample(
794 /// client: &ClusterManager
795 /// ) -> Result<()> {
796 /// let response = client.set_maintenance_policy()
797 /// /* set fields */
798 /// .send().await?;
799 /// println!("response {:?}", response);
800 /// Ok(())
801 /// }
802 /// ```
803 pub fn set_maintenance_policy(&self) -> super::builder::cluster_manager::SetMaintenancePolicy {
804 super::builder::cluster_manager::SetMaintenancePolicy::new(self.inner.clone())
805 }
806
807 /// Lists subnetworks that are usable for creating clusters in a project.
808 ///
809 /// # Example
810 /// ```
811 /// # use google_cloud_container_v1::client::ClusterManager;
812 /// use google_cloud_gax::paginator::ItemPaginator as _;
813 /// use google_cloud_container_v1::Result;
814 /// async fn sample(
815 /// client: &ClusterManager
816 /// ) -> Result<()> {
817 /// let mut list = client.list_usable_subnetworks()
818 /// /* set fields */
819 /// .by_item();
820 /// while let Some(item) = list.next().await.transpose()? {
821 /// println!("{:?}", item);
822 /// }
823 /// Ok(())
824 /// }
825 /// ```
826 pub fn list_usable_subnetworks(
827 &self,
828 ) -> super::builder::cluster_manager::ListUsableSubnetworks {
829 super::builder::cluster_manager::ListUsableSubnetworks::new(self.inner.clone())
830 }
831
832 /// Checks the cluster compatibility with Autopilot mode, and returns a list of
833 /// compatibility issues.
834 ///
835 /// # Example
836 /// ```
837 /// # use google_cloud_container_v1::client::ClusterManager;
838 /// use google_cloud_container_v1::Result;
839 /// async fn sample(
840 /// client: &ClusterManager
841 /// ) -> Result<()> {
842 /// let response = client.check_autopilot_compatibility()
843 /// /* set fields */
844 /// .send().await?;
845 /// println!("response {:?}", response);
846 /// Ok(())
847 /// }
848 /// ```
849 pub fn check_autopilot_compatibility(
850 &self,
851 ) -> super::builder::cluster_manager::CheckAutopilotCompatibility {
852 super::builder::cluster_manager::CheckAutopilotCompatibility::new(self.inner.clone())
853 }
854
855 /// Fetch upgrade information of a specific cluster.
856 ///
857 /// # Example
858 /// ```
859 /// # use google_cloud_container_v1::client::ClusterManager;
860 /// use google_cloud_container_v1::Result;
861 /// async fn sample(
862 /// client: &ClusterManager
863 /// ) -> Result<()> {
864 /// let response = client.fetch_cluster_upgrade_info()
865 /// /* set fields */
866 /// .send().await?;
867 /// println!("response {:?}", response);
868 /// Ok(())
869 /// }
870 /// ```
871 pub fn fetch_cluster_upgrade_info(
872 &self,
873 ) -> super::builder::cluster_manager::FetchClusterUpgradeInfo {
874 super::builder::cluster_manager::FetchClusterUpgradeInfo::new(self.inner.clone())
875 }
876
877 /// Fetch upgrade information of a specific node pool.
878 ///
879 /// # Example
880 /// ```
881 /// # use google_cloud_container_v1::client::ClusterManager;
882 /// use google_cloud_container_v1::Result;
883 /// async fn sample(
884 /// client: &ClusterManager
885 /// ) -> Result<()> {
886 /// let response = client.fetch_node_pool_upgrade_info()
887 /// /* set fields */
888 /// .send().await?;
889 /// println!("response {:?}", response);
890 /// Ok(())
891 /// }
892 /// ```
893 pub fn fetch_node_pool_upgrade_info(
894 &self,
895 ) -> super::builder::cluster_manager::FetchNodePoolUpgradeInfo {
896 super::builder::cluster_manager::FetchNodePoolUpgradeInfo::new(self.inner.clone())
897 }
898}