How can I make a cloned Arc live long enough for a tokio task in Rust?

I am having convincing the compiler that certain variables live long enough.

Here is my code:

use trust_dns_resolver::{
    config::{ResolverConfig, ResolverOpts},
    TokioAsyncResolver,
};

fn main() {
    let rt = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .unwrap();

    rt.block_on(async {
        let cb_domain_iter = vec!["example.com.", "google.com.", "facebook.com."];

        let resolver = Arc::new(
            TokioAsyncResolver::tokio(ResolverConfig::default(), ResolverOpts::default())
                .expect("Could not create resolver"),
        );

        let tasks = cb_domain_iter.iter().map(move |domain| {
            let resolver_ref = resolver.clone();
            let domain_ref = domain.clone(); // we can get rid of this .clone() if we really have to by putting cb_domain_iter behind an Arc<>
            tokio::spawn(resolver_ref.lookup_ip(domain_ref))
        });

        for join in tasks {
            join.await;
        }
    })
}

Since I .await each of the JoinHandles, the resolver and cb_domain_iter should live long enough for the tokio tasks. However, the compiler is unaware of this as seen in the error message:

error[E0597]: `resolver_ref` does not live long enough
  --> src/bin/test.rs:26:26
   |
26 |             tokio::spawn(resolver_ref.lookup_ip(domain_ref))
   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |                          |
   |                          borrowed value does not live long enough
   |                          argument requires that `resolver_ref` is borrowed for `'static`
27 |         });
   |         - `resolver_ref` dropped here while still borrowed

This brings me to a bit of a dillema. From what it tells me, I understand that the reference clone I create is dropped before the tokio spawn starts, but I am having trouble making the tokio task own the reference synchronously.

There may be ways to coerce this to work by changing the structure of the code, but I was really hoping for something simple & functional like what the .map(...) is providing here. So ideally the solution continues to use the functional features of rust.

I think the solution is to simply move resolver_ref and domain_ref into the future you give to spawn instead of giving it some temporary:

tokio::spawn(async move {resolver_ref.lookup_ip(domain_ref).await })