Struct kube_client::Api
source · pub struct Api<K> { /* private fields */ }
Expand description
Implementations§
source§impl<K> Api<K>
impl<K> Api<K>
PUSH/PUT/POST/GET abstractions
sourcepub async fn get(&self, name: &str) -> Result<K>
pub async fn get(&self, name: &str) -> Result<K>
Get a named resource
use k8s_openapi::api::core::v1::Pod;
let pods: Api<Pod> = Api::namespaced(client, "apps");
let p: Pod = pods.get("blog").await?;
§Errors
This function assumes that the object is expected to always exist, and returns Error
if it does not.
Consider using Api::get_opt
if you need to handle missing objects.
sourcepub async fn get_metadata(&self, name: &str) -> Result<PartialObjectMeta<K>>
pub async fn get_metadata(&self, name: &str) -> Result<PartialObjectMeta<K>>
Get only the metadata for a named resource as PartialObjectMeta
use kube::{Api, core::PartialObjectMeta};
use k8s_openapi::api::core::v1::Pod;
let pods: Api<Pod> = Api::namespaced(client, "apps");
let p: PartialObjectMeta<Pod> = pods.get_metadata("blog").await?;
Note that the type may be converted to ObjectMeta
through the usual
conversion traits.
§Errors
This function assumes that the object is expected to always exist, and returns Error
if it does not.
Consider using Api::get_metadata_opt
if you need to handle missing objects.
sourcepub async fn get_with(&self, name: &str, gp: &GetParams) -> Result<K>
pub async fn get_with(&self, name: &str, gp: &GetParams) -> Result<K>
Get a named resource with an explicit resourceVersion
This function allows the caller to pass in a GetParams
type containing
a resourceVersion
to a Get call.
For example
use k8s_openapi::api::core::v1::Pod;
let pods: Api<Pod> = Api::namespaced(client, "apps");
let p: Pod = pods.get_with("blog", &GetParams::any()).await?;
§Errors
This function assumes that the object is expected to always exist, and returns Error
if it does not.
Consider using Api::get_opt
if you need to handle missing objects.
sourcepub async fn get_metadata_with(
&self,
name: &str,
gp: &GetParams,
) -> Result<PartialObjectMeta<K>>
pub async fn get_metadata_with( &self, name: &str, gp: &GetParams, ) -> Result<PartialObjectMeta<K>>
Get the metadata of an object using an explicit resourceVersion
This function allows the caller to pass in a GetParams
type containing
a resourceVersion
to a Get call.
For example
use kube::{Api, api::GetParams, core::PartialObjectMeta};
use k8s_openapi::api::core::v1::Pod;
let pods: Api<Pod> = Api::namespaced(client, "apps");
let p: PartialObjectMeta<Pod> = pods.get_metadata_with("blog", &GetParams::any()).await?;
Note that the type may be converted to ObjectMeta
through the usual
conversion traits.
§Errors
This function assumes that the object is expected to always exist, and returns Error
if it does not.
Consider using Api::get_metadata_opt
if you need to handle missing objects.
sourcepub async fn get_metadata_opt(
&self,
name: &str,
) -> Result<Option<PartialObjectMeta<K>>>
pub async fn get_metadata_opt( &self, name: &str, ) -> Result<Option<PartialObjectMeta<K>>>
Get Metadata for a named resource if it exists, returns None
if it doesn’t exit
use k8s_openapi::api::core::v1::Pod;
let pods: Api<Pod> = Api::namespaced(client, "apps");
if let Some(pod) = pods.get_metadata_opt("blog").await? {
// Pod was found
} else {
// Pod was not found
}
Note that PartialObjectMeta
embeds the raw ObjectMeta
.
sourcepub async fn list(&self, lp: &ListParams) -> Result<ObjectList<K>>
pub async fn list(&self, lp: &ListParams) -> Result<ObjectList<K>>
Get a list of resources
You use this to get everything, or a subset matching fields/labels, say:
use kube::api::{Api, ListParams, ResourceExt};
use k8s_openapi::api::core::v1::Pod;
let pods: Api<Pod> = Api::namespaced(client, "apps");
let lp = ListParams::default().labels("app=blog"); // for this app only
for p in pods.list(&lp).await? {
println!("Found Pod: {}", p.name_any());
}
sourcepub async fn list_metadata(
&self,
lp: &ListParams,
) -> Result<ObjectList<PartialObjectMeta<K>>>
pub async fn list_metadata( &self, lp: &ListParams, ) -> Result<ObjectList<PartialObjectMeta<K>>>
Get a list of resources that contains only their metadata as
Similar to list, you use this to get everything, or a subset matching fields/labels. For example
use kube::api::{Api, ListParams, ResourceExt};
use kube::core::{ObjectMeta, ObjectList, PartialObjectMeta};
use k8s_openapi::api::core::v1::Pod;
let pods: Api<Pod> = Api::namespaced(client, "apps");
let lp = ListParams::default().labels("app=blog"); // for this app only
let list: ObjectList<PartialObjectMeta<Pod>> = pods.list_metadata(&lp).await?;
for p in list {
println!("Found Pod: {}", p.name_any());
}
sourcepub async fn create(&self, pp: &PostParams, data: &K) -> Result<K>where
K: Serialize,
pub async fn create(&self, pp: &PostParams, data: &K) -> Result<K>where
K: Serialize,
Create a resource
This function requires a type that Serializes to K
, which can be:
- Raw string YAML
- easy to port from existing files
- error prone (run-time errors on typos due to failed serialize attempts)
- very error prone (can write invalid YAML)
- An instance of the struct itself
- easy to instantiate for CRDs (you define the struct)
- dense to instantiate for
k8s_openapi
types (due to many optionals) - compile-time safety
- but still possible to write invalid native types (validation at apiserver)
serde_json::json!
macro instantiatedserde_json::Value
- Tradeoff between the two
- Easy partially filling of native
k8s_openapi
types (most fields optional) - Partial safety against runtime errors (at least you must write valid JSON)
Note that this method cannot write to the status object (when it exists) of a resource.
To set status objects please see Api::replace_status
or Api::patch_status
.
sourcepub async fn delete(
&self,
name: &str,
dp: &DeleteParams,
) -> Result<Either<K, Status>>
pub async fn delete( &self, name: &str, dp: &DeleteParams, ) -> Result<Either<K, Status>>
Delete a named resource
When you get a K
via Left
, your delete has started.
When you get a Status
via Right
, this should be a a 2XX style
confirmation that the object being gone.
4XX and 5XX status types are returned as an Err(kube_client::Error::Api)
.
use kube::api::{Api, DeleteParams};
use k8s_openapi::apiextensions_apiserver::pkg::apis::apiextensions::v1 as apiexts;
use apiexts::CustomResourceDefinition;
let crds: Api<CustomResourceDefinition> = Api::all(client);
crds.delete("foos.clux.dev", &DeleteParams::default()).await?
.map_left(|o| println!("Deleting CRD: {:?}", o.status))
.map_right(|s| println!("Deleted CRD: {:?}", s));
sourcepub async fn delete_collection(
&self,
dp: &DeleteParams,
lp: &ListParams,
) -> Result<Either<ObjectList<K>, Status>>
pub async fn delete_collection( &self, dp: &DeleteParams, lp: &ListParams, ) -> Result<Either<ObjectList<K>, Status>>
Delete a collection of resources
When you get an ObjectList<K>
via Left
, your delete has started.
When you get a Status
via Right
, this should be a a 2XX style
confirmation that the object being gone.
4XX and 5XX status types are returned as an Err(kube_client::Error::Api)
.
use kube::api::{Api, DeleteParams, ListParams, ResourceExt};
use k8s_openapi::api::core::v1::Pod;
let pods: Api<Pod> = Api::namespaced(client, "apps");
match pods.delete_collection(&DeleteParams::default(), &ListParams::default()).await? {
either::Left(list) => {
let names: Vec<_> = list.iter().map(ResourceExt::name_any).collect();
println!("Deleting collection of pods: {:?}", names);
},
either::Right(status) => {
println!("Deleted collection of pods: status={:?}", status);
}
}
sourcepub async fn patch<P: Serialize + Debug>(
&self,
name: &str,
pp: &PatchParams,
patch: &Patch<P>,
) -> Result<K>
pub async fn patch<P: Serialize + Debug>( &self, name: &str, pp: &PatchParams, patch: &Patch<P>, ) -> Result<K>
Patch a subset of a resource’s properties
Takes a Patch
along with PatchParams
for the call.
use kube::api::{Api, PatchParams, Patch, Resource};
use k8s_openapi::api::core::v1::Pod;
let pods: Api<Pod> = Api::namespaced(client, "apps");
let patch = serde_json::json!({
"apiVersion": "v1",
"kind": "Pod",
"metadata": {
"name": "blog"
},
"spec": {
"activeDeadlineSeconds": 5
}
});
let params = PatchParams::apply("myapp");
let patch = Patch::Apply(&patch);
let o_patched = pods.patch("blog", ¶ms, &patch).await?;
Note that this method cannot write to the status object (when it exists) of a resource.
To set status objects please see Api::replace_status
or Api::patch_status
.
sourcepub async fn patch_metadata<P: Serialize + Debug>(
&self,
name: &str,
pp: &PatchParams,
patch: &Patch<P>,
) -> Result<PartialObjectMeta<K>>
pub async fn patch_metadata<P: Serialize + Debug>( &self, name: &str, pp: &PatchParams, patch: &Patch<P>, ) -> Result<PartialObjectMeta<K>>
Patch a metadata subset of a resource’s properties from PartialObjectMeta
Takes a Patch
along with PatchParams
for the call.
Patches can be constructed raw using serde_json::json!
or from ObjectMeta
via PartialObjectMetaExt
.
use kube::api::{Api, PatchParams, Patch, Resource};
use kube::core::{PartialObjectMetaExt, ObjectMeta};
use k8s_openapi::api::core::v1::Pod;
let pods: Api<Pod> = Api::namespaced(client, "apps");
let metadata = ObjectMeta {
labels: Some([("key".to_string(), "value".to_string())].into()),
..Default::default()
}.into_request_partial::<Pod>();
let params = PatchParams::apply("myapp");
let o_patched = pods.patch_metadata("blog", ¶ms, &Patch::Apply(&metadata)).await?;
println!("Patched {}", o_patched.metadata.name.unwrap());
§Warnings
The TypeMeta
(apiVersion + kind) of a patch request (required for apply patches)
must match the underlying type that is being patched (e.g. “v1” + “Pod”).
The returned TypeMeta
will always be {“meta.k8s.io/v1”, “PartialObjectMetadata”}.
These constraints are encoded into PartialObjectMetaExt
.
This method can write to non-metadata fields such as spec if included in the patch.
sourcepub async fn replace(&self, name: &str, pp: &PostParams, data: &K) -> Result<K>where
K: Serialize,
pub async fn replace(&self, name: &str, pp: &PostParams, data: &K) -> Result<K>where
K: Serialize,
Replace a resource entirely with a new one
This is used just like Api::create
, but with one additional instruction:
You must set metadata.resourceVersion
in the provided data because k8s
will not accept an update unless you actually knew what the last version was.
Thus, to use this function, you need to do a get
then a replace
with its result.
use kube::api::{Api, PostParams, ResourceExt};
use k8s_openapi::api::batch::v1::Job;
let jobs: Api<Job> = Api::namespaced(client, "apps");
let j = jobs.get("baz").await?;
let j_new: Job = serde_json::from_value(serde_json::json!({
"apiVersion": "batch/v1",
"kind": "Job",
"metadata": {
"name": "baz",
"resourceVersion": j.resource_version(),
},
"spec": {
"template": {
"metadata": {
"name": "empty-job-pod"
},
"spec": {
"containers": [{
"name": "empty",
"image": "alpine:latest"
}],
"restartPolicy": "Never",
}
}
}
}))?;
jobs.replace("baz", &PostParams::default(), &j_new).await?;
Consider mutating the result of api.get
rather than recreating it.
Note that this method cannot write to the status object (when it exists) of a resource.
To set status objects please see Api::replace_status
or Api::patch_status
.
sourcepub async fn watch(
&self,
wp: &WatchParams,
version: &str,
) -> Result<impl Stream<Item = Result<WatchEvent<K>>>>
pub async fn watch( &self, wp: &WatchParams, version: &str, ) -> Result<impl Stream<Item = Result<WatchEvent<K>>>>
Watch a list of resources
This returns a future that awaits the initial response,
then you can stream the remaining buffered WatchEvent
objects.
Note that a watch
call can terminate for many reasons (even before the specified
WatchParams::timeout
is triggered), and will have to be re-issued
with the last seen resource version when or if it closes.
Consider using a managed watcher
to deal with automatic re-watches and error cases.
use kube::api::{Api, WatchParams, ResourceExt, WatchEvent};
use k8s_openapi::api::batch::v1::Job;
use futures::{StreamExt, TryStreamExt};
let jobs: Api<Job> = Api::namespaced(client, "apps");
let lp = WatchParams::default()
.fields("metadata.name=my_job")
.timeout(20); // upper bound of how long we watch for
let mut stream = jobs.watch(&lp, "0").await?.boxed();
while let Some(status) = stream.try_next().await? {
match status {
WatchEvent::Added(s) => println!("Added {}", s.name_any()),
WatchEvent::Modified(s) => println!("Modified: {}", s.name_any()),
WatchEvent::Deleted(s) => println!("Deleted {}", s.name_any()),
WatchEvent::Bookmark(s) => {},
WatchEvent::Error(s) => println!("{}", s),
}
}
sourcepub async fn watch_metadata(
&self,
wp: &WatchParams,
version: &str,
) -> Result<impl Stream<Item = Result<WatchEvent<PartialObjectMeta<K>>>>>
pub async fn watch_metadata( &self, wp: &WatchParams, version: &str, ) -> Result<impl Stream<Item = Result<WatchEvent<PartialObjectMeta<K>>>>>
Watch a list of metadata for a given resources
This returns a future that awaits the initial response,
then you can stream the remaining buffered WatchEvent
objects.
Note that a watch_metadata
call can terminate for many reasons (even
before the specified WatchParams::timeout
is triggered), and will
have to be re-issued with the last seen resource version when or if it
closes.
Consider using a managed metadata_watcher
to deal with automatic re-watches and error cases.
use kube::api::{Api, WatchParams, ResourceExt, WatchEvent};
use k8s_openapi::api::batch::v1::Job;
use futures::{StreamExt, TryStreamExt};
let jobs: Api<Job> = Api::namespaced(client, "apps");
let lp = WatchParams::default()
.fields("metadata.name=my_job")
.timeout(20); // upper bound of how long we watch for
let mut stream = jobs.watch(&lp, "0").await?.boxed();
while let Some(status) = stream.try_next().await? {
match status {
WatchEvent::Added(s) => println!("Added {}", s.metadata.name.unwrap()),
WatchEvent::Modified(s) => println!("Modified: {}", s.metadata.name.unwrap()),
WatchEvent::Deleted(s) => println!("Deleted {}", s.metadata.name.unwrap()),
WatchEvent::Bookmark(s) => {},
WatchEvent::Error(s) => println!("{}", s),
}
}
source§impl<K> Api<K>where
K: Clone + DeserializeOwned,
impl<K> Api<K>where
K: Clone + DeserializeOwned,
Methods for scale subresource.
sourcepub async fn patch_scale<P: Serialize + Debug>(
&self,
name: &str,
pp: &PatchParams,
patch: &Patch<P>,
) -> Result<Scale>
pub async fn patch_scale<P: Serialize + Debug>( &self, name: &str, pp: &PatchParams, patch: &Patch<P>, ) -> Result<Scale>
Update the scale subresource
sourcepub async fn replace_scale(
&self,
name: &str,
pp: &PostParams,
data: Vec<u8>,
) -> Result<Scale>
pub async fn replace_scale( &self, name: &str, pp: &PostParams, data: Vec<u8>, ) -> Result<Scale>
Replace the scale subresource
source§impl<K> Api<K>
impl<K> Api<K>
Arbitrary subresources
sourcepub async fn get_subresource(
&self,
subresource_name: &str,
name: &str,
) -> Result<K>
pub async fn get_subresource( &self, subresource_name: &str, name: &str, ) -> Result<K>
Display one or many sub-resources.
sourcepub async fn create_subresource<T>(
&self,
subresource_name: &str,
name: &str,
pp: &PostParams,
data: Vec<u8>,
) -> Result<T>where
T: DeserializeOwned,
pub async fn create_subresource<T>(
&self,
subresource_name: &str,
name: &str,
pp: &PostParams,
data: Vec<u8>,
) -> Result<T>where
T: DeserializeOwned,
Create an instance of the subresource
sourcepub async fn patch_subresource<P: Serialize + Debug>(
&self,
subresource_name: &str,
name: &str,
pp: &PatchParams,
patch: &Patch<P>,
) -> Result<K>
pub async fn patch_subresource<P: Serialize + Debug>( &self, subresource_name: &str, name: &str, pp: &PatchParams, patch: &Patch<P>, ) -> Result<K>
Patch an instance of the subresource
sourcepub async fn replace_subresource(
&self,
subresource_name: &str,
name: &str,
pp: &PostParams,
data: Vec<u8>,
) -> Result<K>
pub async fn replace_subresource( &self, subresource_name: &str, name: &str, pp: &PostParams, data: Vec<u8>, ) -> Result<K>
Replace an instance of the subresource
source§impl<K> Api<K>
impl<K> Api<K>
sourcepub async fn replace_ephemeral_containers(
&self,
name: &str,
pp: &PostParams,
data: &K,
) -> Result<K>where
K: Serialize,
pub async fn replace_ephemeral_containers(
&self,
name: &str,
pp: &PostParams,
data: &K,
) -> Result<K>where
K: Serialize,
Replace the ephemeral containers sub resource entirely.
This functions in the same way as Api::replace
except only .spec.ephemeralcontainers
is replaced, everything else is ignored.
Note that ephemeral containers may not be changed or removed once attached to a pod.
You way want to patch the underlying resource to gain access to the main container process,
see the documentation for sharedProcessNamespace
.
See the Kubernetes documentation for more details.
Api::patch_ephemeral_containers
may be more ergonomic, as you can will avoid having to first fetch the
existing subresources with an approriate merge strategy, see the examples for more details.
Example of using replace_ephemeral_containers
:
use k8s_openapi::api::core::v1::Pod;
use kube::{Api, api::PostParams};
let pods: Api<Pod> = Api::namespaced(client, "apps");
let pp = PostParams::default();
// Get pod object with ephemeral containers.
let mut mypod = pods.get_ephemeral_containers("mypod").await?;
// If there were existing ephemeral containers, we would have to append
// new containers to the list before calling replace_ephemeral_containers.
assert_eq!(mypod.spec.as_mut().unwrap().ephemeral_containers, None);
// Add an ephemeral container to the pod object.
mypod.spec.as_mut().unwrap().ephemeral_containers = Some(serde_json::from_value(serde_json::json!([
{
"name": "myephemeralcontainer",
"image": "busybox:1.34.1",
"command": ["sh", "-c", "sleep 20"],
},
]))?);
pods.replace_ephemeral_containers("mypod", &pp, &mypod).await?;
sourcepub async fn patch_ephemeral_containers<P: Serialize>(
&self,
name: &str,
pp: &PatchParams,
patch: &Patch<P>,
) -> Result<K>
pub async fn patch_ephemeral_containers<P: Serialize>( &self, name: &str, pp: &PatchParams, patch: &Patch<P>, ) -> Result<K>
Patch the ephemeral containers sub resource
Any partial object containing the ephemeral containers sub resource is valid as long as the complete structure for the object is present, as shown below.
You way want to patch the underlying resource to gain access to the main container process,
see the docs for sharedProcessNamespace
.
Ephemeral containers may not be changed or removed once attached to a pod. Therefore if the chosen merge strategy overwrites the existing ephemeral containers, you will have to fetch the existing ephemeral containers first. In order to append your new ephemeral containers to the existing list before patching. See some examples and discussion related to merge strategies in Kubernetes here. The example below uses a strategic merge patch which does not require
See the Kubernetes
documentation
for more information about ephemeral containers.
Example of using patch_ephemeral_containers
:
use kube::api::{Api, PatchParams, Patch};
use k8s_openapi::api::core::v1::Pod;
let pods: Api<Pod> = Api::namespaced(client, "apps");
let pp = PatchParams::default(); // stratetgic merge patch
// Note that the strategic merge patch will concatenate the
// lists of ephemeral containers so we avoid having to fetch the
// current list and append to it manually.
let patch = serde_json::json!({
"spec":{
"ephemeralContainers": [
{
"name": "myephemeralcontainer",
"image": "busybox:1.34.1",
"command": ["sh", "-c", "sleep 20"],
},
]
}});
pods.patch_ephemeral_containers("mypod", &pp, &Patch::Strategic(patch)).await?;
sourcepub async fn get_ephemeral_containers(&self, name: &str) -> Result<K>
pub async fn get_ephemeral_containers(&self, name: &str) -> Result<K>
Get the named resource with the ephemeral containers subresource.
This returns the whole K, with metadata and spec.
source§impl<K> Api<K>where
K: DeserializeOwned,
impl<K> Api<K>where
K: DeserializeOwned,
Methods for status subresource.
sourcepub async fn get_status(&self, name: &str) -> Result<K>
pub async fn get_status(&self, name: &str) -> Result<K>
Get the named resource with a status subresource
This actually returns the whole K, with metadata, and spec.
sourcepub async fn patch_status<P: Serialize + Debug>(
&self,
name: &str,
pp: &PatchParams,
patch: &Patch<P>,
) -> Result<K>
pub async fn patch_status<P: Serialize + Debug>( &self, name: &str, pp: &PatchParams, patch: &Patch<P>, ) -> Result<K>
Patch fields on the status object
NB: Requires that the resource has a status subresource.
use kube::api::{Api, PatchParams, Patch};
use k8s_openapi::api::batch::v1::Job;
let jobs: Api<Job> = Api::namespaced(client, "apps");
let mut j = jobs.get("baz").await?;
let pp = PatchParams::default(); // json merge patch
let data = serde_json::json!({
"status": {
"succeeded": 2
}
});
let o = jobs.patch_status("baz", &pp, &Patch::Merge(data)).await?;
assert_eq!(o.status.unwrap().succeeded, Some(2));
sourcepub async fn replace_status(
&self,
name: &str,
pp: &PostParams,
data: Vec<u8>,
) -> Result<K>
pub async fn replace_status( &self, name: &str, pp: &PostParams, data: Vec<u8>, ) -> Result<K>
Replace every field on the status object
This works similarly to the Api::replace
method, but .spec
is ignored.
You can leave out the .spec
entirely from the serialized output.
use kube::api::{Api, PostParams};
use k8s_openapi::api::batch::v1::{Job, JobStatus};
let jobs: Api<Job> = Api::namespaced(client, "apps");
let mut o = jobs.get_status("baz").await?; // retrieve partial object
o.status = Some(JobStatus::default()); // update the job part
let pp = PostParams::default();
let o = jobs.replace_status("baz", &pp, serde_json::to_vec(&o)?).await?;
source§impl<K> Api<K>where
K: DeserializeOwned + Log,
impl<K> Api<K>where
K: DeserializeOwned + Log,
sourcepub async fn log_stream(
&self,
name: &str,
lp: &LogParams,
) -> Result<impl AsyncBufRead>
pub async fn log_stream( &self, name: &str, lp: &LogParams, ) -> Result<impl AsyncBufRead>
Stream the logs via AsyncBufRead
.
Log stream can be processsed using AsyncReadExt
and AsyncBufReadExt
.
§Example
use futures::{AsyncBufReadExt, TryStreamExt};
let pods: Api<Pod> = Api::default_namespaced(client);
let mut logs = pods
.log_stream("my-pod", &LogParams::default()).await?
.lines();
while let Some(line) = logs.try_next().await? {
println!("{}", line);
}
source§impl<K> Api<K>where
K: DeserializeOwned + Evict,
impl<K> Api<K>where
K: DeserializeOwned + Evict,
source§impl<K> Api<K>
impl<K> Api<K>
sourcepub async fn attach(
&self,
name: &str,
ap: &AttachParams,
) -> Result<AttachedProcess>
pub async fn attach( &self, name: &str, ap: &AttachParams, ) -> Result<AttachedProcess>
Attach to pod
source§impl<K> Api<K>
impl<K> Api<K>
sourcepub async fn exec<I, T>(
&self,
name: &str,
command: I,
ap: &AttachParams,
) -> Result<AttachedProcess>
pub async fn exec<I, T>( &self, name: &str, command: I, ap: &AttachParams, ) -> Result<AttachedProcess>
Execute a command in a pod
source§impl<K> Api<K>
impl<K> Api<K>
sourcepub async fn portforward(
&self,
name: &str,
ports: &[u16],
) -> Result<Portforwarder>
pub async fn portforward( &self, name: &str, ports: &[u16], ) -> Result<Portforwarder>
Forward ports of a pod
source§impl Api<CertificateSigningRequest>
impl Api<CertificateSigningRequest>
sourcepub async fn patch_approval<P: Serialize>(
&self,
name: &str,
pp: &PatchParams,
patch: &Patch<P>,
) -> Result<CertificateSigningRequest>
pub async fn patch_approval<P: Serialize>( &self, name: &str, pp: &PatchParams, patch: &Patch<P>, ) -> Result<CertificateSigningRequest>
Partially update approval of the specified CertificateSigningRequest.
sourcepub async fn get_approval(
&self,
name: &str,
) -> Result<CertificateSigningRequest>
pub async fn get_approval( &self, name: &str, ) -> Result<CertificateSigningRequest>
Get the CertificateSigningRequest. May differ from get(name)
source§impl Api<ServiceAccount>
impl Api<ServiceAccount>
sourcepub async fn create_token_request(
&self,
name: &str,
pp: &PostParams,
token_request: &TokenRequest,
) -> Result<TokenRequest>
pub async fn create_token_request( &self, name: &str, pp: &PostParams, token_request: &TokenRequest, ) -> Result<TokenRequest>
Create a TokenRequest of a ServiceAccount
source§impl<K: Resource + Clone + DeserializeOwned + Debug> Api<K>
impl<K: Resource + Clone + DeserializeOwned + Debug> Api<K>
sourcepub async fn entry<'a>(&'a self, name: &'a str) -> Result<Entry<'a, K>>
pub async fn entry<'a>(&'a self, name: &'a str) -> Result<Entry<'a, K>>
Gets a given object’s “slot” on the Kubernetes API, designed for “get-or-create” and “get-and-modify” patterns
This is similar to HashMap::entry
, but the Entry
must be OccupiedEntry::commit
ed for changes to be persisted.
§Usage
let kube = kube::Client::try_default().await?;
let cms = kube::Api::<ConfigMap>::namespaced(kube, "default");
cms
// Try to get `entry-example` if it exists
.entry("entry-example").await?
// Modify object if it already exists
.and_modify(|cm| {
cm.data
.get_or_insert_with(BTreeMap::default)
.insert("already-exists".to_string(), "true".to_string());
})
// Provide a default object if it does not exist
.or_insert(|| ConfigMap::default())
// Modify the object unconditionally now that we have provided a default value
.and_modify(|cm| {
cm.data
.get_or_insert_with(BTreeMap::default)
.insert("modified".to_string(), "true".to_string());
})
// Save changes
.commit(&kube::api::PostParams::default()).await?;
source§impl<K: Resource> Api<K>
impl<K: Resource> Api<K>
Api constructors for Resource implementors with custom DynamicTypes
This generally means resources created via DynamicObject
.
sourcepub fn all_with(client: Client, dyntype: &K::DynamicType) -> Self
pub fn all_with(client: Client, dyntype: &K::DynamicType) -> Self
Cluster level resources, or resources viewed across all namespaces
This function accepts K::DynamicType
so it can be used with dynamic resources.
§Warning
This variant can only list
and watch
namespaced resources and is commonly used with a watcher
.
If you need to create/patch/replace/get on a namespaced resource, you need a separate Api::namespaced
.
sourcepub fn namespaced_with(
client: Client,
ns: &str,
dyntype: &K::DynamicType,
) -> Selfwhere
K: Resource<Scope = DynamicResourceScope>,
pub fn namespaced_with(
client: Client,
ns: &str,
dyntype: &K::DynamicType,
) -> Selfwhere
K: Resource<Scope = DynamicResourceScope>,
Namespaced resource within a given namespace
This function accepts K::DynamicType
so it can be used with dynamic resources.
sourcepub fn default_namespaced_with(client: Client, dyntype: &K::DynamicType) -> Selfwhere
K: Resource<Scope = DynamicResourceScope>,
pub fn default_namespaced_with(client: Client, dyntype: &K::DynamicType) -> Selfwhere
K: Resource<Scope = DynamicResourceScope>,
Namespaced resource within the default namespace
This function accepts K::DynamicType
so it can be used with dynamic resources.
The namespace is either configured on context
in the kubeconfig
or falls back to default
when running locally, and it’s using the service account’s
namespace when deployed in-cluster.
sourcepub fn into_client(self) -> Client
pub fn into_client(self) -> Client
Consume self and return the Client
sourcepub fn resource_url(&self) -> &str
pub fn resource_url(&self) -> &str
Return a reference to the current resource url path
source§impl<K: Resource> Api<K>
impl<K: Resource> Api<K>
Api constructors for Resource implementors with Default DynamicTypes
This generally means structs implementing k8s_openapi::Resource
.
sourcepub fn all(client: Client) -> Self
pub fn all(client: Client) -> Self
Cluster level resources, or resources viewed across all namespaces
Namespace scoped resource allowing querying across all namespaces:
use k8s_openapi::api::core::v1::Pod;
let api: Api<Pod> = Api::all(client);
Cluster scoped resources also use this entrypoint:
use k8s_openapi::api::core::v1::Node;
let api: Api<Node> = Api::all(client);
§Warning
This variant can only list
and watch
namespaced resources and is commonly used with a watcher
.
If you need to create/patch/replace/get on a namespaced resource, you need a separate Api::namespaced
.
sourcepub fn namespaced(client: Client, ns: &str) -> Selfwhere
K: Resource<Scope = NamespaceResourceScope>,
pub fn namespaced(client: Client, ns: &str) -> Selfwhere
K: Resource<Scope = NamespaceResourceScope>,
Namespaced resource within a given namespace
use k8s_openapi::api::core::v1::Pod;
let api: Api<Pod> = Api::namespaced(client, "default");
This will ONLY work on namespaced resources as set by Scope
:
use k8s_openapi::api::core::v1::Node;
let api: Api<Node> = Api::namespaced(client, "default"); // resource not namespaced!
For dynamic type information, use Api::namespaced_with
variants.
sourcepub fn default_namespaced(client: Client) -> Selfwhere
K: Resource<Scope = NamespaceResourceScope>,
pub fn default_namespaced(client: Client) -> Selfwhere
K: Resource<Scope = NamespaceResourceScope>,
Namespaced resource within the default namespace
The namespace is either configured on context
in the kubeconfig
or falls back to default
when running locally, and it’s using the service account’s
namespace when deployed in-cluster.
use k8s_openapi::api::core::v1::Pod;
let api: Api<Pod> = Api::default_namespaced(client);
This will ONLY work on namespaced resources as set by Scope
:
use k8s_openapi::api::core::v1::Node;
let api: Api<Node> = Api::default_namespaced(client); // resource not namespaced!
Trait Implementations§
Auto Trait Implementations§
impl<K> Freeze for Api<K>
impl<K> !RefUnwindSafe for Api<K>
impl<K> Send for Api<K>
impl<K> Sync for Api<K>
impl<K> Unpin for Api<K>
impl<K> !UnwindSafe for Api<K>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§default unsafe fn clone_to_uninit(&self, dst: *mut T)
default unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)