How to use kube::Api::create with raw string YAMLs?

[mati865]

According to the docs this function accepts "Raw string YAML" but I cannot find the obvious way to use it.

My code (minimized):

fn foo(namespace: &str, raw_template: String) -> anyhow::Result<()> {
        let k8s_client = Client::try_default().await?;
        let api = Api::namespaced(k8s_client, &namespace);
        api.create(&PostParams::default(), &raw_template)
            .await?;
}

shows an error:

error[E0277]: the trait bound `std::string::String: k8s_openapi::Metadata` is not satisfied
  --> foo/src/bar.rs:40:19
   |
40 |         let api = Api::namespaced(k8s_client, &namespace);
   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `k8s_openapi::Metadata` is not implemented for `std::string::String`, which is required by `std::string::String: kube::Resource`
   |
   = help: the following other types implement trait `k8s_openapi::Metadata`:
             APIService
             Binding
             CSIDriver
             CSINode
             CSIStorageCapacity
             CertificateSigningRequest
             ClusterRole
             ClusterRoleBinding
           and 77 others
   = note: required for `std::string::String` to implement `kube::Resource`

My use case is trying to deploy YAMLs that contain multiple resources separated by ---.

[clux]

if the yaml are arbitrary resources, then you'd probably want to use the dynamic api.

Take a look at the kubectl example in the apply section:

kube/examples/kubectl.rs

Lines 156 to 181 in 7ff120a

	async fn apply(&self, client: Client, discovery: &Discovery) -> Result<()> {
	let ssapply = PatchParams::apply("kubectl-light").force();
	let pth = self.file.clone().expect("apply needs a -f file supplied");
	let yaml =
	std::fs::read_to_string(&pth).with_context(|| format!("Failed to read {}", pth.display()))?;
	for doc in multidoc_deserialize(&yaml)? {
	let obj: DynamicObject = serde_yaml::from_value(doc)?;
	let namespace = obj.metadata.namespace.as_deref().or(self.namespace.as_deref());
	let gvk = if let Some(tm) = &obj.types {
	GroupVersionKind::try_from(tm)?
	} else {
	bail!("cannot apply object without valid TypeMeta {:?}", obj);
	};
	let name = obj.name_any();
	if let Some((ar, caps)) = discovery.resolve_gvk(&gvk) {
	let api = dynamic_api(ar, caps, client.clone(), namespace, false);
	trace!("Applying {}: \n{}", gvk.kind, serde_yaml::to_string(&obj)?);
	let data: serde_json::Value = serde_json::to_value(&obj)?;
	let _r = api.patch(&name, &ssapply, &Patch::Apply(data)).await?;
	info!("applied {} {}", gvk.kind, name);
	} else {
	warn!("Cannot apply document for unknown {:?}", gvk);
	}
	}
	Ok(())
	}

i suspect that's pretty similar to what you want (it's using server-side apply - via api.patch rather than api.create, but this should be better than using create anyway)

[mati865]

Thank you for the reply, that's great solution.

At first I planned to use server-side, but since I'm doing only a proof of concept I decided to start with create as according to the docs I could just call it with a yaml. If that's not possible maybe docs need a correction?

[clux]

you should be able to do basically the same as above there with api.create without much trouble (s/PatchParams/PostParams ++).

i just try to steer people away from the older (non-idempotent) create/replace interfaces unless there's a particular need need to use them (because they come with potential needs for conflict resolution). you should be able to call either with a full object, .patch is just a little more lenient in accepting partial objects / patches.