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