Struct kube::client::Client[−][src]

pub struct Client { /* fields omitted */ }

This is supported on crate feature client only.

Expand description

Client for connecting with a Kubernetes cluster.

The easiest way to instantiate the client is either by inferring the configuration from the environment using Client::try_default or with an existing Config using Client::try_from.

Implementations

[src]

impl Client

[src]

pub fn new<S, B, T>(service: S, default_namespace: T) -> Self where
 S: Service<Request<Body>, Response = Response> + Send + 'static,
 S::Future: Send + 'static,
 S::Error: Into<BoxError>,
 B: Body<Data = Bytes> + Send + 'static,
 B::Error: Error + Send + Sync + 'static,
 T: Into<String>,

Create a Client using a custom Service stack.

ConfigExt provides extensions for building a custom stack.

To create with the default stack with a Config, use Client::try_from.

To create with the default stack with an inferred Config, use Client::try_default.

Example

use kube::{client::ConfigExt, Client, Config};
use tower::ServiceBuilder;

let config = Config::infer().await?;
let service = ServiceBuilder::new()
    .layer(config.base_uri_layer())
    .option_layer(config.auth_layer()?)
    .service(hyper::Client::new());
let client = Client::new(service, config.default_namespace);

[src]

pub async fn try_default() -> Result<Self>

Create and initialize a Client using the inferred configuration.

Will use Config::infer to try in-cluster enironment variables first, then fallback to the local kubeconfig.

Will fail if neither configuration could be loaded.

If you already have a Config then use Client::try_from instead.

[src]

pub async fn connect(
&self,
request: Request<Vec<u8>>
) -> Result<WebSocketStream<Upgraded>>

This is supported on crate feature ws only.

Make WebSocket connection.

[src]

pub async fn request<T>(&self, request: Request<Vec<u8>>) -> Result<T> where
T: DeserializeOwned,

Perform a raw HTTP request against the API and deserialize the response as JSON to some known type.

[src]

pub async fn request_text(&self, request: Request<Vec<u8>>) -> Result<String>

Perform a raw HTTP request against the API and get back the response as a string

[src]

pub async fn request_text_stream(
&self,
request: Request<Vec<u8>>
) -> Result<impl Stream<Item = Result<Bytes>>>

Perform a raw HTTP request against the API and get back the response as a stream of bytes

[src]

pub async fn request_status<T>(
 &self,
 request: Request<Vec<u8>>
) -> Result<Either<T, Status>> where
 T: DeserializeOwned,

Perform a raw HTTP request against the API and get back either an object deserialized as JSON or a Status Object.

[src]

pub async fn request_events<T>(
 &self,
 request: Request<Vec<u8>>
) -> Result<impl TryStream<Item = Result<WatchEvent<T>>>> where
 T: Clone + DeserializeOwned,

Perform a raw request and get back a stream of WatchEvent objects

[src]

impl Client

Low level discovery methods using k8s_openapi types.

Consider using the discovery module for easier-to-use variants of this functionality. The following methods might be deprecated to avoid confusion between similarly named types within discovery.

[src]

pub async fn apiserver_version(&self) -> Result<Info>

Returns apiserver version.

[src]

pub async fn list_api_groups(&self) -> Result<APIGroupList>

Lists api groups that apiserver serves.

[src]

pub async fn list_api_group_resources(
&self,
apiversion: &str
) -> Result<APIResourceList>

Lists resources served in given API group.

Example usage:

let apigroups = client.list_api_groups().await?;
for g in apigroups.groups {
    let ver = g
        .preferred_version
        .as_ref()
        .or_else(|| g.versions.first())
        .expect("preferred or versions exists");
    let apis = client.list_api_group_resources(&ver.group_version).await?;
    dbg!(apis);
}