diff --git a/docs/src/main/asciidoc/getting-started-testing.adoc b/docs/src/main/asciidoc/getting-started-testing.adoc
index 8f69be4a2c16e..b7aada35bd742 100644
--- a/docs/src/main/asciidoc/getting-started-testing.adoc
+++ b/docs/src/main/asciidoc/getting-started-testing.adoc
@@ -987,11 +987,68 @@ A very common need is to start some services on which your Quarkus application d
 By simply annotating any test in the test suite with `@QuarkusTestResource`, Quarkus will run the corresponding `QuarkusTestResourceLifecycleManager` before any tests are run.
 A test suite is also free to utilize multiple `@QuarkusTestResource` annotations, in which case all the corresponding `QuarkusTestResourceLifecycleManager` objects will be run before the tests. When using multiple test resources they can be started concurrently. For that you need to set `@QuarkusTestResource(parallel = true)`.
 
+NOTE: test resources are global, even if they are defined on a test class or custom profile, which means they will all be activated for all tests, even though we do
+remove duplicates. If you want to only enable a test resource on a single test class or test profile, you can use `@QuarkusTestResource(restrictToAnnotatedClass = true)`.
+
 Quarkus provides a few implementations of `QuarkusTestResourceLifecycleManager` out of the box (see `io.quarkus.test.h2.H2DatabaseTestResource` which starts an H2 database, or `io.quarkus.test.kubernetes.client.KubernetesMockServerTestResource` which starts a mock Kubernetes API server),
 but it is common to create custom implementations to address specific application needs.
 Common cases include starting docker containers using https://www.testcontainers.org/[Testcontainers] (an example of which can be found https://github.com/quarkusio/quarkus-quickstarts/blob/master/kafka-quickstart/src/test/java/org/acme/kafka/KafkaResource.java[here]),
 or starting a mock HTTP server using http://wiremock.org/[Wiremock] (an example of which can be found https://github.com/geoand/quarkus-test-demo/blob/master/src/test/java/org/acme/getting/started/country/WiremockCountries.java[here]).
 
+=== Annotation-based test resources
+
+It is possible to write test resources that are enabled and configured using annotations. This is enabled by placing the `@QuarkusTestResource`
+on an annotation which will be used to enable and configure the test resource.
+
+For example, this defines the `@WithKubernetesTestServer` annotation, which you can use on your tests to activate the `KubernetesServerTestResource`,
+but only for the annotated test class. You can also place them on your `QuarkusTestProfile` test profiles.
+
+[source,java]
+----
+@QuarkusTestResource(KubernetesServerTestResource.class)
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface WithKubernetesTestServer {
+    /**
+     * Start it with HTTPS
+     */
+    boolean https() default false;
+
+    /**
+     * Start it in CRUD mode
+     */
+    boolean crud() default true;
+
+    /**
+     * Port to use, defaults to any available port
+     */
+    int port() default 0;
+}
+----
+
+The `KubernetesServerTestResource` class has to implement the
+`QuarkusTestResourceConfigurableLifecycleManager` interface in order to be configured using the previous annotation:
+
+[source,java]
+----
+public class KubernetesServerTestResource
+        implements QuarkusTestResourceConfigurableLifecycleManager<WithKubernetesTestServer> {
+
+    private boolean https = false;
+    private boolean crud = true;
+    private int port = 0;
+
+    @Override
+    public void init(WithKubernetesTestServer annotation) {
+        this.https = annotation.https();
+        this.crud = annotation.crud();
+        this.port = annotation.port();
+    }
+
+    // ...
+}
+----
+
 == Hang Detection
 
 `@QuarkusTest` has support for hang detection to help diagnose any unexpected hangs. If no progress is made for a specified
diff --git a/docs/src/main/asciidoc/kubernetes-client.adoc b/docs/src/main/asciidoc/kubernetes-client.adoc
index 547a64ad48ac7..8624958617491 100644
--- a/docs/src/main/asciidoc/kubernetes-client.adoc
+++ b/docs/src/main/asciidoc/kubernetes-client.adoc
@@ -71,9 +71,9 @@ public class KubernetesClientProducer {
 
 == Testing
 
-To make testing against a mock Kubernetes API extremely simple, Quarkus provides the `KubernetesMockServerTestResource` which automatically launches
+To make testing against a mock Kubernetes API extremely simple, Quarkus provides the `WithKubernetesTestServer` annotation which automatically launches
 a mock of the Kubernetes API server and sets the proper environment variables needed so that the Kubernetes Client configures itself to use said mock.
-Tests can inject the mock and set it up in any way necessary for the particular testing using the `@MockServer` annotation.
+Tests can inject the mock server and set it up in any way necessary for the particular testing using the `@KubernetesTestServer` annotation.
 
 Let's assume we have a REST endpoint defined like so:
 
@@ -100,12 +100,13 @@ We could write a test for this endpoint very easily like so:
 
 [source%nowrap,java]
 ----
-@QuarkusTestResource(KubernetesMockServerTestResource.class)
+// you can even configure aspects like crud, https and port on this annotation
+@WithKubernetesTestServer
 @QuarkusTest
 public class KubernetesClientTest {
 
-    @MockServer
-    KubernetesMockServer mockServer;
+    @KubernetesTestServer
+    KubernetesServer mockServer;
 
     @BeforeEach
     public void before() {
@@ -139,14 +140,14 @@ Note that to take advantage of these features, the `quarkus-test-kubernetes-clie
 </dependency>
 ----
 
-You can create a `CustomKubernetesMockServerTestResource.java` to ensure all your `@QuarkusTest` enabled test classes share the same mock server setup:
+Alternately, you can create a `CustomKubernetesMockServerTestResource.java` to ensure all your `@QuarkusTest` enabled test classes share the same mock server setup:
 
 [source%nowrap,java]
 ----
-public class CustomKubernetesMockServerTestResource extends KubernetesMockServerTestResource {
+public class CustomKubernetesMockServerTestResource extends KubernetesServerTestResource {
 
     @Override
-    public void configureMockServer(KubernetesMockServer mockServer) {
+    public void configureMockServer(KubernetesServer mockServer) {
         mockServer.expect().get().withPath("/api/v1/namespaces/test/pods")
                 .andReturn(200, new PodList())
                 .always();
diff --git a/integration-tests/kubernetes-client/pom.xml b/integration-tests/kubernetes-client/pom.xml
index dc37c18c7b122..ea2df35547387 100644
--- a/integration-tests/kubernetes-client/pom.xml
+++ b/integration-tests/kubernetes-client/pom.xml
@@ -93,6 +93,9 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <runOrder>alphabetical</runOrder>
+                </configuration>
                 <executions>
                     <!--
                     The prod mode tests need to be part of a different execution to ensure that they don't mess with the standard tests.
diff --git a/integration-tests/kubernetes-client/src/main/java/io/quarkus/it/kubernetes/client/Pods.java b/integration-tests/kubernetes-client/src/main/java/io/quarkus/it/kubernetes/client/Pods.java
index 7c82dedde42a1..610ebbbfa63ad 100644
--- a/integration-tests/kubernetes-client/src/main/java/io/quarkus/it/kubernetes/client/Pods.java
+++ b/integration-tests/kubernetes-client/src/main/java/io/quarkus/it/kubernetes/client/Pods.java
@@ -52,7 +52,8 @@ public Response updateFirst(@PathParam("namespace") String namespace) {
         final Pod pod = pods.get(0);
         final String podName = pod.getMetadata().getName();
         // would normally do some kind of meaningful update here
-        Pod updatedPod = new PodBuilder().withNewMetadata().withName(podName).withNewResourceVersion("12345").endMetadata()
+        Pod updatedPod = new PodBuilder().withNewMetadata().withName(podName).withNewResourceVersion("12345")
+                .addToLabels("key1", "value1").endMetadata()
                 .build();
 
         updatedPod = kubernetesClient.pods().withName(podName).createOrReplace(updatedPod);
diff --git a/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/AbsentConfigMapPropertiesPMT.java b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/AbsentConfigMapPropertiesPMT.java
index b218f88090e9d..81cd82376b350 100644
--- a/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/AbsentConfigMapPropertiesPMT.java
+++ b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/AbsentConfigMapPropertiesPMT.java
@@ -11,7 +11,7 @@
 import io.quarkus.test.QuarkusProdModeTest;
 import io.quarkus.test.common.QuarkusTestResource;
 
-@QuarkusTestResource(CustomKubernetesMockServerTestResource.class)
+@QuarkusTestResource(value = CustomKubernetesMockServerTestResource.class, restrictToAnnotatedClass = true)
 public class AbsentConfigMapPropertiesPMT {
 
     @RegisterExtension
diff --git a/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/ConfigMapPropertiesTest.java b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/ConfigMapPropertiesTest.java
index f2f9e599aab57..03d0102941a06 100644
--- a/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/ConfigMapPropertiesTest.java
+++ b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/ConfigMapPropertiesTest.java
@@ -8,7 +8,7 @@
 import io.quarkus.test.common.QuarkusTestResource;
 import io.quarkus.test.junit.QuarkusTest;
 
-@QuarkusTestResource(CustomKubernetesMockServerTestResource.class)
+@QuarkusTestResource(value = CustomKubernetesMockServerTestResource.class, restrictToAnnotatedClass = true)
 @QuarkusTest
 public class ConfigMapPropertiesTest {
 
diff --git a/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/CustomKubernetesTestServerTestResource.java b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/CustomKubernetesTestServerTestResource.java
new file mode 100644
index 0000000000000..a28944ab803c4
--- /dev/null
+++ b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/CustomKubernetesTestServerTestResource.java
@@ -0,0 +1,65 @@
+package io.quarkus.it.kubernetes.client;
+
+import java.util.Base64;
+
+import io.fabric8.kubernetes.api.model.ConfigMapBuilder;
+import io.fabric8.kubernetes.api.model.SecretBuilder;
+import io.quarkus.test.kubernetes.client.KubernetesServerTestResource;
+
+public class CustomKubernetesTestServerTestResource extends KubernetesServerTestResource {
+
+    // setup the ConfigMap objects that the application expects to lookup configuration from
+    @Override
+    protected void configureServer() {
+        server.getClient().inNamespace("test").configMaps().create(configMapBuilder("cmap1")
+                .addToData("dummy", "dummy")
+                .addToData("overridden.secret", "cm") // will be overridden since secrets have a higher priority
+                .addToData("some.prop1", "val1")
+                .addToData("some.prop2", "val2")
+                .addToData("some.prop4", "v4") // will be overridden since cmap2 has a higher priority
+                .addToData("some.prop5", "val5")
+                .addToData("application.properties", "some.prop3=val3")
+                .addToData("application.yaml", "some:\n  prop4: val4").build());
+
+        server.getClient().inNamespace("test").configMaps().create(configMapBuilder("cmap2")
+                .addToData("application.yaml", "some:\n  prop4: val4").build());
+
+        server.getClient().inNamespace("test").configMaps().create(configMapBuilder("cmap3")
+                .addToData("dummy", "dummyFromDemo")
+                .addToData("some.prop1", "val1FromDemo")
+                .addToData("some.prop2", "val2FromDemo")
+                .addToData("some.prop5", "val5FromDemo")
+                .addToData("application.properties", "some.prop3=val3FromDemo")
+                .addToData("application.yaml", "some:\n  prop4: val4FromDemo").build());
+
+        server.getClient().inNamespace("test").secrets().create(secretBuilder("s1")
+                .addToData("dummysecret", encodeValue("dummysecret"))
+                .addToData("overridden.secret", encodeValue("secret"))
+                .addToData("secret.prop1", encodeValue("val1"))
+                .addToData("secret.prop2", encodeValue("val2"))
+                .addToData("application.properties", encodeValue("secret.prop3=val3"))
+                .addToData("application.yaml", encodeValue("secret:\n  prop4: val4")).build());
+
+        server.getClient().inNamespace("test").secrets().create(secretBuilder("s1")
+                .addToData("dummysecret", encodeValue("dummysecretFromDemo"))
+                .addToData("overridden.secret", encodeValue("secretFromDemo"))
+                .addToData("secret.prop1", encodeValue("val1FromDemo"))
+                .addToData("secret.prop2", encodeValue("val2FromDemo"))
+                .addToData("application.properties", encodeValue("secret.prop3=val3FromDemo"))
+                .addToData("application.yaml", encodeValue("secret:\n  prop4: val4FromDemo")).build());
+    }
+
+    private ConfigMapBuilder configMapBuilder(String name) {
+        return new ConfigMapBuilder().withNewMetadata()
+                .withName(name).endMetadata();
+    }
+
+    private SecretBuilder secretBuilder(String name) {
+        return new SecretBuilder().withNewMetadata()
+                .withName(name).endMetadata();
+    }
+
+    private String encodeValue(String value) {
+        return Base64.getEncoder().encodeToString(value.getBytes());
+    }
+}
diff --git a/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/KubernetesClientTest.java b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/KubernetesClientTest.java
index 69f9a35c237dc..304cc1e5bb779 100644
--- a/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/KubernetesClientTest.java
+++ b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/KubernetesClientTest.java
@@ -19,7 +19,7 @@
  * KubernetesClientTest.TestResource contains the entire process of setting up the Mock Kubernetes API Server
  * It has to live there otherwise the Kubernetes client in native mode won't be able to locate the mock API Server
  */
-@QuarkusTestResource(CustomKubernetesMockServerTestResource.class)
+@QuarkusTestResource(value = CustomKubernetesMockServerTestResource.class, restrictToAnnotatedClass = true)
 @QuarkusTest
 public class KubernetesClientTest {
 
diff --git a/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/KubernetesNewClientTest.java b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/KubernetesNewClientTest.java
new file mode 100644
index 0000000000000..2222bbb00a8ed
--- /dev/null
+++ b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/KubernetesNewClientTest.java
@@ -0,0 +1,52 @@
+package io.quarkus.it.kubernetes.client;
+
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.is;
+
+import org.junit.jupiter.api.Test;
+
+import io.fabric8.kubernetes.api.model.Pod;
+import io.fabric8.kubernetes.api.model.PodBuilder;
+import io.fabric8.kubernetes.client.server.mock.KubernetesServer;
+import io.quarkus.test.common.QuarkusTestResource;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.kubernetes.client.KubernetesTestServer;
+import io.restassured.RestAssured;
+
+/*
+ * KubernetesClientTest.TestResource contains the entire process of setting up the Mock Kubernetes API Server
+ * It has to live there otherwise the Kubernetes client in native mode won't be able to locate the mock API Server
+ */
+@QuarkusTestResource(value = CustomKubernetesTestServerTestResource.class, restrictToAnnotatedClass = true)
+@QuarkusTest
+public class KubernetesNewClientTest {
+
+    @KubernetesTestServer
+    private KubernetesServer mockServer;
+
+    @Test
+    public void testInteractionWithAPIServer() throws InterruptedException {
+        setupMockServerForTest();
+
+        RestAssured.when().get("/pod/test").then()
+                .body("size()", is(2)).body(containsString("pod1"), containsString("pod2"));
+
+        RestAssured.when().delete("/pod/test").then()
+                .statusCode(204);
+
+        RestAssured.when().put("/pod/test").then()
+                .body(containsString("value1"));
+
+        RestAssured.when().post("/pod/test").then()
+                .body(containsString("12345"));
+    }
+
+    private void setupMockServerForTest() {
+        Pod pod1 = new PodBuilder().withNewMetadata().withName("pod1").withNamespace("test").and().build();
+        Pod pod2 = new PodBuilder().withNewMetadata().withName("pod2").withNamespace("test").and().build();
+
+        mockServer.getClient().inNamespace("test").pods().create(pod1);
+        mockServer.getClient().inNamespace("test").pods().create(pod2);
+    }
+
+}
diff --git a/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/KubernetesNewClientTestIT.java b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/KubernetesNewClientTestIT.java
new file mode 100644
index 0000000000000..24e771ca88ccd
--- /dev/null
+++ b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/KubernetesNewClientTestIT.java
@@ -0,0 +1,8 @@
+package io.quarkus.it.kubernetes.client;
+
+import io.quarkus.test.junit.NativeImageTest;
+
+@NativeImageTest
+public class KubernetesNewClientTestIT extends KubernetesNewClientTest {
+
+}
diff --git a/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/KubernetesTestServerOnProfileTest.java b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/KubernetesTestServerOnProfileTest.java
new file mode 100644
index 0000000000000..6bb8e6d2c4222
--- /dev/null
+++ b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/KubernetesTestServerOnProfileTest.java
@@ -0,0 +1,72 @@
+package io.quarkus.it.kubernetes.client;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Consumer;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import io.fabric8.kubernetes.client.server.mock.KubernetesServer;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.junit.QuarkusTestProfile;
+import io.quarkus.test.junit.TestProfile;
+import io.quarkus.test.kubernetes.client.KubernetesTestServer;
+import io.quarkus.test.kubernetes.client.WithKubernetesTestServer;
+
+/*
+ * This class has no native-image test because it relies on setting config overrides that clash
+ * with native image build config.
+ * This is the same test as KubernetesTestServerTest but with the test resource annotation on the profile
+ */
+@TestProfile(KubernetesTestServerOnProfileTest.MyProfile.class)
+@QuarkusTest
+public class KubernetesTestServerOnProfileTest {
+
+    private static KubernetesServer setupServer;
+
+    public static class Setup implements Consumer<KubernetesServer> {
+
+        @Override
+        public void accept(KubernetesServer t) {
+            setupServer = t;
+        }
+
+    }
+
+    @KubernetesTestServer
+    private KubernetesServer mockServer;
+
+    @Test
+    public void testConfiguration() throws InterruptedException {
+        // we can't really test CRUD, and HTTPS doesn't work
+        Assertions.assertEquals(10001, mockServer.getMockServer().getPort());
+        Assertions.assertSame(mockServer, setupServer);
+    }
+
+    @WithKubernetesTestServer(https = false, crud = true, port = 10001, setup = KubernetesTestServerOnProfileTest.Setup.class)
+    public static class MyProfile implements QuarkusTestProfile {
+
+        @Override
+        public Map<String, String> getConfigOverrides() {
+            Map<String, String> overrides = new HashMap<>();
+            // do not fetch config from kubernetes
+            overrides.put("quarkus.kubernetes-config.enabled", "false");
+            overrides.put("quarkus.kubernetes-config.secrets.enabled", "false");
+            // get rid of errors due to us not populating config from kubernetes
+            overrides.put("dummy", "asd");
+            overrides.put("some.prop1", "asd");
+            overrides.put("some.prop2", "asd");
+            overrides.put("some.prop3", "asd");
+            overrides.put("some.prop4", "asd");
+            overrides.put("some.prop5", "asd");
+            overrides.put("secret.prop1", "asd");
+            overrides.put("secret.prop2", "asd");
+            overrides.put("secret.prop3", "asd");
+            overrides.put("secret.prop4", "asd");
+            overrides.put("overridden.secret", "asd");
+            overrides.put("dummysecret", "asd");
+            return overrides;
+        }
+    }
+}
diff --git a/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/KubernetesTestServerTest.java b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/KubernetesTestServerTest.java
new file mode 100644
index 0000000000000..f2c185005b7bd
--- /dev/null
+++ b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/KubernetesTestServerTest.java
@@ -0,0 +1,70 @@
+package io.quarkus.it.kubernetes.client;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Consumer;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import io.fabric8.kubernetes.client.server.mock.KubernetesServer;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.junit.QuarkusTestProfile;
+import io.quarkus.test.junit.TestProfile;
+import io.quarkus.test.kubernetes.client.KubernetesTestServer;
+import io.quarkus.test.kubernetes.client.WithKubernetesTestServer;
+
+/*
+ * This class has no native-image test because it relies on setting config overrides that clash
+ * with native image build config.
+ */
+@TestProfile(KubernetesTestServerTest.MyProfile.class)
+@WithKubernetesTestServer(https = false, crud = true, port = 10001, setup = KubernetesTestServerTest.Setup.class)
+@QuarkusTest
+public class KubernetesTestServerTest {
+
+    private static KubernetesServer setupServer;
+
+    public static class Setup implements Consumer<KubernetesServer> {
+
+        @Override
+        public void accept(KubernetesServer t) {
+            setupServer = t;
+        }
+
+    }
+
+    @KubernetesTestServer
+    private KubernetesServer mockServer;
+
+    @Test
+    public void testConfiguration() throws InterruptedException {
+        // we can't really test CRUD, and HTTPS doesn't work
+        Assertions.assertEquals(10001, mockServer.getMockServer().getPort());
+        Assertions.assertSame(mockServer, setupServer);
+    }
+
+    public static class MyProfile implements QuarkusTestProfile {
+        @Override
+        public Map<String, String> getConfigOverrides() {
+            Map<String, String> overrides = new HashMap<>();
+            // do not fetch config from kubernetes
+            overrides.put("quarkus.kubernetes-config.enabled", "false");
+            overrides.put("quarkus.kubernetes-config.secrets.enabled", "false");
+            // get rid of errors due to us not populating config from kubernetes
+            overrides.put("dummy", "asd");
+            overrides.put("some.prop1", "asd");
+            overrides.put("some.prop2", "asd");
+            overrides.put("some.prop3", "asd");
+            overrides.put("some.prop4", "asd");
+            overrides.put("some.prop5", "asd");
+            overrides.put("secret.prop1", "asd");
+            overrides.put("secret.prop2", "asd");
+            overrides.put("secret.prop3", "asd");
+            overrides.put("secret.prop4", "asd");
+            overrides.put("overridden.secret", "asd");
+            overrides.put("dummysecret", "asd");
+            return overrides;
+        }
+    }
+}
diff --git a/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/NamespacedConfigMapPropertiesTest.java b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/NamespacedConfigMapPropertiesTest.java
index c73a419dea3bc..ea203c1c90b15 100644
--- a/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/NamespacedConfigMapPropertiesTest.java
+++ b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/NamespacedConfigMapPropertiesTest.java
@@ -10,7 +10,7 @@
 import io.quarkus.test.junit.QuarkusTestProfile;
 import io.quarkus.test.junit.TestProfile;
 
-@QuarkusTestResource(CustomKubernetesMockServerTestResource.class)
+@QuarkusTestResource(value = CustomKubernetesMockServerTestResource.class, restrictToAnnotatedClass = true)
 @TestProfile(NamespacedConfigMapPropertiesTest.MyProfile.class)
 @QuarkusTest
 public class NamespacedConfigMapPropertiesTest {
diff --git a/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/SecretPropertiesTest.java b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/SecretPropertiesTest.java
index 05072d9326dab..425fef9d150f7 100644
--- a/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/SecretPropertiesTest.java
+++ b/integration-tests/kubernetes-client/src/test/java/io/quarkus/it/kubernetes/client/SecretPropertiesTest.java
@@ -8,7 +8,7 @@
 import io.quarkus.test.common.QuarkusTestResource;
 import io.quarkus.test.junit.QuarkusTest;
 
-@QuarkusTestResource(CustomKubernetesMockServerTestResource.class)
+@QuarkusTestResource(value = CustomKubernetesMockServerTestResource.class, restrictToAnnotatedClass = true)
 @QuarkusTest
 public class SecretPropertiesTest {
 
diff --git a/test-framework/common/src/main/java/io/quarkus/test/common/QuarkusTestResource.java b/test-framework/common/src/main/java/io/quarkus/test/common/QuarkusTestResource.java
index f9f01995c7887..a439aff41d39b 100644
--- a/test-framework/common/src/main/java/io/quarkus/test/common/QuarkusTestResource.java
+++ b/test-framework/common/src/main/java/io/quarkus/test/common/QuarkusTestResource.java
@@ -42,6 +42,13 @@
      */
     boolean parallel() default false;
 
+    /**
+     * Whether this annotation should only be enabled if it is placed on the currently running test class or test profile.
+     * Note that this defaults to true for meta-annotations since meta-annotations are only considered
+     * for the current test class or test profile.
+     */
+    boolean restrictToAnnotatedClass() default false;
+
     @Target(ElementType.TYPE)
     @Retention(RetentionPolicy.RUNTIME)
     @Documented
diff --git a/test-framework/common/src/main/java/io/quarkus/test/common/QuarkusTestResourceConfigurableLifecycleManager.java b/test-framework/common/src/main/java/io/quarkus/test/common/QuarkusTestResourceConfigurableLifecycleManager.java
new file mode 100644
index 0000000000000..9b082629b62be
--- /dev/null
+++ b/test-framework/common/src/main/java/io/quarkus/test/common/QuarkusTestResourceConfigurableLifecycleManager.java
@@ -0,0 +1,9 @@
+package io.quarkus.test.common;
+
+import java.lang.annotation.Annotation;
+
+public interface QuarkusTestResourceConfigurableLifecycleManager<ConfigAnnotation extends Annotation>
+        extends QuarkusTestResourceLifecycleManager {
+    default void init(ConfigAnnotation annotation) {
+    }
+}
diff --git a/test-framework/common/src/main/java/io/quarkus/test/common/TestResourceManager.java b/test-framework/common/src/main/java/io/quarkus/test/common/TestResourceManager.java
index b388e92bbcce1..3455b05802ba1 100644
--- a/test-framework/common/src/main/java/io/quarkus/test/common/TestResourceManager.java
+++ b/test-framework/common/src/main/java/io/quarkus/test/common/TestResourceManager.java
@@ -1,6 +1,7 @@
 package io.quarkus.test.common;
 
 import java.io.Closeable;
+import java.lang.annotation.Annotation;
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -23,6 +24,7 @@
 import org.eclipse.microprofile.config.spi.ConfigProviderResolver;
 import org.jboss.jandex.AnnotationInstance;
 import org.jboss.jandex.AnnotationValue;
+import org.jboss.jandex.ClassInfo;
 import org.jboss.jandex.DotName;
 import org.jboss.jandex.IndexView;
 
@@ -33,12 +35,13 @@ public class TestResourceManager implements Closeable {
     private final List<TestResourceEntry> allTestResourceEntries;
     private Map<String, String> oldSystemProps;
     private boolean started = false;
+    private boolean hasPerTestResources = false;
 
     public TestResourceManager(Class<?> testClass) {
-        this(testClass, Collections.emptyList(), false);
+        this(testClass, null, Collections.emptyList(), false);
     }
 
-    public TestResourceManager(Class<?> testClass, List<TestResourceClassEntry> additionalTestResources,
+    public TestResourceManager(Class<?> testClass, Class<?> profileClass, List<TestResourceClassEntry> additionalTestResources,
             boolean disableGlobalTestResources) {
         this.parallelTestResourceEntries = new ArrayList<>();
         this.sequentialTestResourceEntries = new ArrayList<>();
@@ -49,7 +52,7 @@ public TestResourceManager(Class<?> testClass, List<TestResourceClassEntry> addi
         if (disableGlobalTestResources) {
             uniqueEntries = new HashSet<>(additionalTestResources);
         } else {
-            uniqueEntries = getUniqueTestResourceClassEntries(testClass, additionalTestResources);
+            uniqueEntries = getUniqueTestResourceClassEntries(testClass, profileClass, additionalTestResources);
         }
         Set<TestResourceClassEntry> remainingUniqueEntries = initParallelTestResources(uniqueEntries);
         initSequentialTestResources(remainingUniqueEntries);
@@ -61,7 +64,14 @@ public TestResourceManager(Class<?> testClass, List<TestResourceClassEntry> addi
     public void init() {
         for (TestResourceEntry entry : allTestResourceEntries) {
             try {
-                entry.getTestResource().init(entry.getArgs());
+                QuarkusTestResourceLifecycleManager testResource = entry.getTestResource();
+                if (testResource instanceof QuarkusTestResourceConfigurableLifecycleManager
+                        && entry.getConfigAnnotation() != null) {
+                    ((QuarkusTestResourceConfigurableLifecycleManager<Annotation>) testResource)
+                            .init(entry.getConfigAnnotation());
+                } else {
+                    testResource.init(entry.getArgs());
+                }
             } catch (Exception e) {
                 throw new RuntimeException("Unable initialize test resource " + entry.getTestResource(), e);
             }
@@ -227,7 +237,7 @@ public int compare(TestResourceEntry o1, TestResourceEntry o2) {
     private TestResourceManager.TestResourceEntry buildTestResourceEntry(TestResourceClassEntry entry) {
         Class<? extends QuarkusTestResourceLifecycleManager> testResourceClass = entry.clazz;
         try {
-            return new TestResourceEntry(testResourceClass.getConstructor().newInstance(), entry.args);
+            return new TestResourceEntry(testResourceClass.getConstructor().newInstance(), entry.args, entry.configAnnotation);
         } catch (InstantiationException
                 | IllegalAccessException
                 | IllegalArgumentException
@@ -238,11 +248,31 @@ private TestResourceManager.TestResourceEntry buildTestResourceEntry(TestResourc
         }
     }
 
-    private Set<TestResourceClassEntry> getUniqueTestResourceClassEntries(Class<?> testClass,
+    private Set<TestResourceClassEntry> getUniqueTestResourceClassEntries(Class<?> testClass, Class<?> profileClass,
             List<TestResourceClassEntry> additionalTestResources) {
         IndexView index = TestClassIndexer.readIndex(testClass);
         Set<TestResourceClassEntry> uniqueEntries = new HashSet<>();
-        for (AnnotationInstance annotation : findQuarkusTestResourceInstances(index)) {
+        // reload the test and profile classes in the right CL
+        Class<?> testClassFromTCCL;
+        Class<?> profileClassFromTCCL;
+        try {
+            testClassFromTCCL = Class.forName(testClass.getName(), false, Thread.currentThread().getContextClassLoader());
+            if (profileClass != null) {
+                profileClassFromTCCL = Class.forName(profileClass.getName(), false,
+                        Thread.currentThread().getContextClassLoader());
+            } else {
+                profileClassFromTCCL = null;
+            }
+        } catch (ClassNotFoundException e) {
+            throw new RuntimeException(e);
+        }
+        // handle meta-annotations: in this case we must rely on reflection because meta-annotations are not indexed
+        // because they are not in the user's test folder but come from test extensions
+        collectMetaAnnotations(testClassFromTCCL, uniqueEntries);
+        if (profileClassFromTCCL != null) {
+            collectMetaAnnotations(profileClassFromTCCL, uniqueEntries);
+        }
+        for (AnnotationInstance annotation : findQuarkusTestResourceInstances(testClass, index)) {
             try {
                 Class<? extends QuarkusTestResourceLifecycleManager> testResourceClass = loadTestResourceClassFromTCCL(
                         annotation.value().asString());
@@ -265,7 +295,12 @@ private Set<TestResourceClassEntry> getUniqueTestResourceClassEntries(Class<?> t
                     isParallel = parallelAnnotationValue.asBoolean();
                 }
 
-                uniqueEntries.add(new TestResourceClassEntry(testResourceClass, args, isParallel));
+                AnnotationValue restrict = annotation.value("restrictToAnnotatedClass");
+                if (restrict != null && restrict.asBoolean()) {
+                    hasPerTestResources = true;
+                }
+
+                uniqueEntries.add(new TestResourceClassEntry(testResourceClass, args, null, isParallel));
             } catch (IllegalArgumentException | SecurityException e) {
                 throw new RuntimeException("Unable to instantiate the test resource " + annotation.value().asString(), e);
             }
@@ -275,6 +310,41 @@ private Set<TestResourceClassEntry> getUniqueTestResourceClassEntries(Class<?> t
         return uniqueEntries;
     }
 
+    private void collectMetaAnnotations(Class<?> testClassFromTCCL, Set<TestResourceClassEntry> uniqueEntries) {
+        while (!testClassFromTCCL.getName().equals("java.lang.Object")) {
+            for (Annotation reflAnnotation : testClassFromTCCL.getAnnotations()) {
+                for (Annotation annotationAnnotation : reflAnnotation.annotationType().getAnnotations()) {
+                    if (annotationAnnotation.annotationType() == QuarkusTestResource.class) {
+                        QuarkusTestResource testResource = (QuarkusTestResource) annotationAnnotation;
+
+                        // NOTE: we don't need to check restrictToAnnotatedClass because by design config-based annotations
+                        // are not discovered outside the test class, so they're restricted
+                        Class<? extends QuarkusTestResourceLifecycleManager> testResourceClass = testResource.value();
+
+                        ResourceArg[] argsAnnotationValue = testResource.initArgs();
+                        Map<String, String> args;
+                        if (argsAnnotationValue.length == 0) {
+                            args = Collections.emptyMap();
+                        } else {
+                            args = new HashMap<>();
+                            for (ResourceArg arg : argsAnnotationValue) {
+                                args.put(arg.name(), arg.value());
+                            }
+                        }
+
+                        boolean isParallel = testResource.parallel();
+
+                        hasPerTestResources = true;
+                        uniqueEntries.add(new TestResourceClassEntry(testResourceClass, args, reflAnnotation, isParallel));
+
+                        break;
+                    }
+                }
+            }
+            testClassFromTCCL = testClassFromTCCL.getSuperclass();
+        }
+    }
+
     @SuppressWarnings("unchecked")
     private Class<? extends QuarkusTestResourceLifecycleManager> loadTestResourceClassFromTCCL(String className) {
         try {
@@ -285,26 +355,58 @@ private Class<? extends QuarkusTestResourceLifecycleManager> loadTestResourceCla
         }
     }
 
-    private Collection<AnnotationInstance> findQuarkusTestResourceInstances(IndexView index) {
-        Set<AnnotationInstance> testResourceAnnotations = new HashSet<>(
-                index.getAnnotations(DotName.createSimple(QuarkusTestResource.class.getName())));
+    private Collection<AnnotationInstance> findQuarkusTestResourceInstances(Class<?> testClass, IndexView index) {
+        // collect all test supertypes for matching per-test targets
+        Set<String> testClasses = new HashSet<>();
+        while (testClass != Object.class) {
+            testClasses.add(testClass.getName());
+            testClass = testClass.getSuperclass();
+        }
+        Set<AnnotationInstance> testResourceAnnotations = new HashSet<>();
+        for (AnnotationInstance annotation : index.getAnnotations(DotName.createSimple(QuarkusTestResource.class.getName()))) {
+            if (keepTestResourceAnnotation(annotation, annotation.target().asClass(), testClasses)) {
+                testResourceAnnotations.add(annotation);
+            }
+        }
+
         for (AnnotationInstance annotation : index
                 .getAnnotations(DotName.createSimple(QuarkusTestResource.List.class.getName()))) {
-            Collections.addAll(testResourceAnnotations, annotation.value().asNestedArray());
+            for (AnnotationInstance nestedAnnotation : annotation.value().asNestedArray()) {
+                // keep the list target
+                if (keepTestResourceAnnotation(nestedAnnotation, annotation.target().asClass(), testClasses)) {
+                    testResourceAnnotations.add(nestedAnnotation);
+                }
+            }
         }
         return testResourceAnnotations;
     }
 
+    // NOTE: called by reflection in QuarkusTestExtension
+    public boolean hasPerTestResources() {
+        return hasPerTestResources;
+    }
+
+    private boolean keepTestResourceAnnotation(AnnotationInstance annotation, ClassInfo targetClass, Set<String> testClasses) {
+        AnnotationValue restrict = annotation.value("restrictToAnnotatedClass");
+        if (restrict != null && restrict.asBoolean()) {
+            return testClasses.contains(targetClass.name().toString('.'));
+        }
+        return true;
+    }
+
     public static class TestResourceClassEntry {
 
         private Class<? extends QuarkusTestResourceLifecycleManager> clazz;
         private Map<String, String> args;
         private boolean parallel;
+        private Annotation configAnnotation;
 
         public TestResourceClassEntry(Class<? extends QuarkusTestResourceLifecycleManager> clazz, Map<String, String> args,
+                Annotation configAnnotation,
                 boolean parallel) {
             this.clazz = clazz;
             this.args = args;
+            this.configAnnotation = configAnnotation;
             this.parallel = parallel;
         }
 
@@ -315,12 +417,13 @@ public boolean equals(Object o) {
             if (o == null || getClass() != o.getClass())
                 return false;
             TestResourceClassEntry that = (TestResourceClassEntry) o;
-            return clazz.equals(that.clazz) && args.equals(that.args) && parallel == that.parallel;
+            return clazz.equals(that.clazz) && args.equals(that.args) && Objects.equals(configAnnotation, that.configAnnotation)
+                    && parallel == that.parallel;
         }
 
         @Override
         public int hashCode() {
-            return Objects.hash(clazz, args, parallel);
+            return Objects.hash(clazz, args, configAnnotation, parallel);
         }
 
         public boolean isParallel() {
@@ -332,14 +435,17 @@ private static class TestResourceEntry {
 
         private final QuarkusTestResourceLifecycleManager testResource;
         private final Map<String, String> args;
+        private final Annotation configAnnotation;
 
         public TestResourceEntry(QuarkusTestResourceLifecycleManager testResource) {
-            this(testResource, Collections.emptyMap());
+            this(testResource, Collections.emptyMap(), null);
         }
 
-        public TestResourceEntry(QuarkusTestResourceLifecycleManager testResource, Map<String, String> args) {
+        public TestResourceEntry(QuarkusTestResourceLifecycleManager testResource, Map<String, String> args,
+                Annotation configAnnotation) {
             this.testResource = testResource;
             this.args = args;
+            this.configAnnotation = configAnnotation;
         }
 
         public QuarkusTestResourceLifecycleManager getTestResource() {
@@ -349,6 +455,10 @@ public QuarkusTestResourceLifecycleManager getTestResource() {
         public Map<String, String> getArgs() {
             return args;
         }
+
+        public Annotation getConfigAnnotation() {
+            return configAnnotation;
+        }
     }
 
 }
diff --git a/test-framework/junit5/src/main/java/io/quarkus/test/junit/NativeTestExtension.java b/test-framework/junit5/src/main/java/io/quarkus/test/junit/NativeTestExtension.java
index 06da57d3aa9c5..9509bbeb0f5e2 100644
--- a/test-framework/junit5/src/main/java/io/quarkus/test/junit/NativeTestExtension.java
+++ b/test-framework/junit5/src/main/java/io/quarkus/test/junit/NativeTestExtension.java
@@ -3,6 +3,7 @@
 import java.io.Closeable;
 import java.io.IOException;
 import java.lang.reflect.Field;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -42,6 +43,10 @@ public class NativeTestExtension
     private static Class<? extends QuarkusTestProfile> quarkusTestProfile;
     private static Throwable firstException; //if this is set then it will be thrown from the very first test that is run, the rest are aborted
 
+    private static Class<?> currentJUnitTestClass;
+
+    private static boolean hasPerTestResources;
+
     @Override
     public void afterEach(ExtensionContext context) throws Exception {
         if (!failedBoot) {
@@ -89,14 +94,13 @@ private ExtensionState ensureStarted(ExtensionContext extensionContext) {
         ExtensionContext root = extensionContext.getRoot();
         ExtensionContext.Store store = root.getStore(ExtensionContext.Namespace.GLOBAL);
         ExtensionState state = store.get(ExtensionState.class.getName(), ExtensionState.class);
-        TestProfile annotation = testClass.getAnnotation(TestProfile.class);
-        Class<? extends QuarkusTestProfile> selectedProfile = null;
-        if (annotation != null) {
-            selectedProfile = annotation.value();
-        }
+        Class<? extends QuarkusTestProfile> selectedProfile = findProfile(testClass);
         boolean wrongProfile = !Objects.equals(selectedProfile, quarkusTestProfile);
-        if ((state == null && !failedBoot) || wrongProfile) {
-            if (wrongProfile) {
+        // we reload the test resources if we changed test class and if we had or will have per-test test resources
+        boolean reloadTestResources = !Objects.equals(extensionContext.getRequiredTestClass(), currentJUnitTestClass)
+                && (hasPerTestResources || QuarkusTestExtension.hasPerTestResources(extensionContext));
+        if ((state == null && !failedBoot) || wrongProfile || reloadTestResources) {
+            if (wrongProfile || reloadTestResources) {
                 if (state != null) {
                     try {
                         state.close();
@@ -118,9 +122,21 @@ private ExtensionState ensureStarted(ExtensionContext extensionContext) {
         return state;
     }
 
+    private Class<? extends QuarkusTestProfile> findProfile(Class<?> testClass) {
+        while (testClass != Object.class) {
+            TestProfile annotation = testClass.getAnnotation(TestProfile.class);
+            if (annotation != null) {
+                return annotation.value();
+            }
+            testClass = testClass.getSuperclass();
+        }
+        return null;
+    }
+
     private ExtensionState doNativeStart(ExtensionContext context, Class<? extends QuarkusTestProfile> profile)
             throws Throwable {
         quarkusTestProfile = profile;
+        currentJUnitTestClass = context.getRequiredTestClass();
         TestResourceManager testResourceManager = null;
         try {
             Class<?> requiredTestClass = context.getRequiredTestClass();
@@ -158,8 +174,11 @@ private ExtensionState doNativeStart(ExtensionContext context, Class<? extends Q
                 }
             }
 
-            testResourceManager = new TestResourceManager(requiredTestClass);
+            testResourceManager = new TestResourceManager(requiredTestClass, quarkusTestProfile,
+                    Collections.emptyList(), profileInstance != null ? profileInstance.disableGlobalTestResources() : false);
             testResourceManager.init();
+            hasPerTestResources = testResourceManager.hasPerTestResources();
+
             additional.putAll(testResourceManager.start());
 
             NativeImageLauncher launcher = new NativeImageLauncher(requiredTestClass);
diff --git a/test-framework/junit5/src/main/java/io/quarkus/test/junit/QuarkusTestExtension.java b/test-framework/junit5/src/main/java/io/quarkus/test/junit/QuarkusTestExtension.java
index f88af54a72e98..76fbf3e7f4abe 100644
--- a/test-framework/junit5/src/main/java/io/quarkus/test/junit/QuarkusTestExtension.java
+++ b/test-framework/junit5/src/main/java/io/quarkus/test/junit/QuarkusTestExtension.java
@@ -6,6 +6,7 @@
 import java.io.Closeable;
 import java.io.File;
 import java.io.IOException;
+import java.lang.annotation.Annotation;
 import java.lang.management.ManagementFactory;
 import java.lang.management.ThreadInfo;
 import java.lang.reflect.Constructor;
@@ -88,6 +89,7 @@
 import io.quarkus.runtime.test.TestHttpEndpointProvider;
 import io.quarkus.test.common.PathTestHelper;
 import io.quarkus.test.common.PropertyTestUtil;
+import io.quarkus.test.common.QuarkusTestResource;
 import io.quarkus.test.common.RestAssuredURLManager;
 import io.quarkus.test.common.TestClassIndexer;
 import io.quarkus.test.common.TestResourceManager;
@@ -129,6 +131,8 @@ public class QuarkusTestExtension
     private static List<Object> afterEachCallbacks;
     private static Class<?> quarkusTestMethodContextClass;
     private static Class<? extends QuarkusTestProfile> quarkusTestProfile;
+    private static boolean hasPerTestResources;
+    private static Class<?> currentJUnitTestClass;
     private static List<Function<Class<?>, String>> testHttpEndpointProviders;
 
     private static DeepClone deepClone;
@@ -187,6 +191,7 @@ private ExtensionState doJavaStart(ExtensionContext context, Class<? extends Qua
         hangTaskKey = hangDetectionExecutor.schedule(hangDetectionTask, hangTimeout.toMillis(), TimeUnit.MILLISECONDS);
 
         quarkusTestProfile = profile;
+        currentJUnitTestClass = context.getRequiredTestClass();
         Closeable testResourceManager = null;
         try {
             final LinkedBlockingDeque<Runnable> shutdownTasks = new LinkedBlockingDeque<>();
@@ -308,12 +313,15 @@ private ExtensionState doJavaStart(ExtensionContext context, Class<? extends Qua
 
             //must be done after the TCCL has been set
             testResourceManager = (Closeable) startupAction.getClassLoader().loadClass(TestResourceManager.class.getName())
-                    .getConstructor(Class.class, List.class, boolean.class)
+                    .getConstructor(Class.class, Class.class, List.class, boolean.class)
                     .newInstance(requiredTestClass,
+                            profile != null ? profile : null,
                             getAdditionalTestResources(profileInstance, startupAction.getClassLoader()),
                             profileInstance != null && profileInstance.disableGlobalTestResources());
             testResourceManager.getClass().getMethod("init").invoke(testResourceManager);
             testResourceManager.getClass().getMethod("start").invoke(testResourceManager);
+            hasPerTestResources = (boolean) testResourceManager.getClass().getMethod("hasPerTestResources")
+                    .invoke(testResourceManager);
 
             populateCallbacks(startupAction.getClassLoader());
 
@@ -400,14 +408,14 @@ private List<Object> getAdditionalTestResources(
         try {
             Constructor<?> testResourceClassEntryConstructor = Class
                     .forName(TestResourceManager.TestResourceClassEntry.class.getName(), true, classLoader)
-                    .getConstructor(Class.class, Map.class, boolean.class);
+                    .getConstructor(Class.class, Map.class, Annotation.class, boolean.class);
 
             List<QuarkusTestProfile.TestResourceEntry> testResources = profileInstance.testResources();
             List<Object> result = new ArrayList<>(testResources.size());
             for (QuarkusTestProfile.TestResourceEntry testResource : testResources) {
                 Object instance = testResourceClassEntryConstructor.newInstance(
                         Class.forName(testResource.getClazz().getName(), true, classLoader), testResource.getArgs(),
-                        testResource.isParallel());
+                        null, testResource.isParallel());
                 result.add(instance);
             }
 
@@ -609,8 +617,11 @@ private ExtensionState ensureStarted(ExtensionContext extensionContext) {
         ExtensionState state = store.get(ExtensionState.class.getName(), ExtensionState.class);
         Class<? extends QuarkusTestProfile> selectedProfile = getQuarkusTestProfile(extensionContext);
         boolean wrongProfile = !Objects.equals(selectedProfile, quarkusTestProfile);
-        if ((state == null && !failedBoot) || wrongProfile) {
-            if (wrongProfile) {
+        // we reload the test resources if we changed test class and if we had or will have per-test test resources
+        boolean reloadTestResources = !Objects.equals(extensionContext.getRequiredTestClass(), currentJUnitTestClass)
+                && (hasPerTestResources || hasPerTestResources(extensionContext));
+        if ((state == null && !failedBoot) || wrongProfile || reloadTestResources) {
+            if (wrongProfile || reloadTestResources) {
                 if (state != null) {
                     try {
                         state.close();
@@ -1174,4 +1185,32 @@ private static void resetHangTimeout() {
             hangTaskKey = hangDetectionExecutor.schedule(hangDetectionTask, hangTimeout.toMillis(), TimeUnit.MILLISECONDS);
         }
     }
+
+    static boolean hasPerTestResources(ExtensionContext extensionContext) {
+        return hasPerTestResources(extensionContext.getRequiredTestClass());
+    }
+
+    public static boolean hasPerTestResources(Class<?> requiredTestClass) {
+        while (requiredTestClass != Object.class) {
+            for (QuarkusTestResource testResource : requiredTestClass.getAnnotationsByType(QuarkusTestResource.class)) {
+                if (testResource.restrictToAnnotatedClass()) {
+                    return true;
+                }
+            }
+            // scan for meta-annotations
+            for (Annotation annotation : requiredTestClass.getAnnotations()) {
+                // skip TestResource annotations
+                if (annotation.annotationType() != QuarkusTestResource.class) {
+                    // look for a TestResource on the annotation itself
+                    if (annotation.annotationType().getAnnotationsByType(QuarkusTestResource.class).length > 0) {
+                        // meta-annotations are per-test scoped for now
+                        return true;
+                    }
+                }
+            }
+            // look up
+            requiredTestClass = requiredTestClass.getSuperclass();
+        }
+        return false;
+    }
 }
diff --git a/test-framework/kubernetes-client/src/main/java/io/quarkus/test/kubernetes/client/AbstractKubernetesTestResource.java b/test-framework/kubernetes-client/src/main/java/io/quarkus/test/kubernetes/client/AbstractKubernetesTestResource.java
new file mode 100644
index 0000000000000..d8be65e175cea
--- /dev/null
+++ b/test-framework/kubernetes-client/src/main/java/io/quarkus/test/kubernetes/client/AbstractKubernetesTestResource.java
@@ -0,0 +1,83 @@
+package io.quarkus.test.kubernetes.client;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.Map;
+
+import io.fabric8.kubernetes.client.Config;
+import io.fabric8.kubernetes.client.GenericKubernetesClient;
+import io.quarkus.test.common.QuarkusTestResourceLifecycleManager;
+
+public abstract class AbstractKubernetesTestResource<T> implements QuarkusTestResourceLifecycleManager {
+    protected T server;
+
+    @Override
+    public Map<String, String> start() {
+        final Map<String, String> systemProps = new HashMap<>();
+        systemProps.put(Config.KUBERNETES_TRUST_CERT_SYSTEM_PROPERTY, "true");
+        systemProps.put(Config.KUBERNETES_AUTH_TRYKUBECONFIG_SYSTEM_PROPERTY, "false");
+        systemProps.put(Config.KUBERNETES_AUTH_TRYSERVICEACCOUNT_SYSTEM_PROPERTY, "false");
+        systemProps.put(Config.KUBERNETES_NAMESPACE_SYSTEM_PROPERTY, "test");
+        systemProps.put(Config.KUBERNETES_HTTP2_DISABLE, "true");
+
+        server = createServer();
+        initServer();
+
+        try (GenericKubernetesClient<?> client = getClient()) {
+            systemProps.put(Config.KUBERNETES_MASTER_SYSTEM_PROPERTY, client.getConfiguration().getMasterUrl());
+        }
+
+        configureServer();
+
+        return systemProps;
+    }
+
+    protected abstract GenericKubernetesClient<?> getClient();
+
+    /**
+     * Can be used by subclasses in order to
+     * setup the mock server before the Quarkus application starts
+     */
+    protected void configureServer() {
+    }
+
+    protected void initServer() {
+    }
+
+    protected abstract T createServer();
+
+    protected boolean useHttps() {
+        return Boolean.getBoolean("quarkus.kubernetes-client.test.https");
+    }
+
+    @Override
+    public void inject(Object testInstance) {
+        Class<?> c = testInstance.getClass();
+        Class<? extends Annotation> annotation = getInjectionAnnotation();
+        Class<?> injectedClass = getInjectedClass();
+        while (c != Object.class) {
+            for (Field f : c.getDeclaredFields()) {
+                if (f.getAnnotation(annotation) != null) {
+                    if (!injectedClass.isAssignableFrom(f.getType())) {
+                        throw new RuntimeException(annotation + " can only be used on fields of type " + injectedClass);
+                    }
+
+                    f.setAccessible(true);
+                    try {
+                        f.set(testInstance, server);
+                        return;
+                    } catch (Exception e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+            }
+            c = c.getSuperclass();
+        }
+    }
+
+    protected abstract Class<?> getInjectedClass();
+
+    protected abstract Class<? extends Annotation> getInjectionAnnotation();
+
+}
diff --git a/test-framework/kubernetes-client/src/main/java/io/quarkus/test/kubernetes/client/KubernetesMockServerTestResource.java b/test-framework/kubernetes-client/src/main/java/io/quarkus/test/kubernetes/client/KubernetesMockServerTestResource.java
index 445979ba56800..94102685abe58 100644
--- a/test-framework/kubernetes-client/src/main/java/io/quarkus/test/kubernetes/client/KubernetesMockServerTestResource.java
+++ b/test-framework/kubernetes-client/src/main/java/io/quarkus/test/kubernetes/client/KubernetesMockServerTestResource.java
@@ -1,81 +1,66 @@
 package io.quarkus.test.kubernetes.client;
 
-import java.lang.reflect.Field;
-import java.util.HashMap;
-import java.util.Map;
+import java.lang.annotation.Annotation;
 
-import io.fabric8.kubernetes.client.Config;
-import io.fabric8.kubernetes.client.NamespacedKubernetesClient;
+import io.fabric8.kubernetes.client.GenericKubernetesClient;
 import io.fabric8.kubernetes.client.server.mock.KubernetesMockServer;
-import io.quarkus.test.common.QuarkusTestResourceLifecycleManager;
 
-public class KubernetesMockServerTestResource implements QuarkusTestResourceLifecycleManager {
-
-    private KubernetesMockServer mockServer;
+/**
+ * @deprecated use {@link KubernetesServerTestResource}
+ */
+@Deprecated
+public class KubernetesMockServerTestResource extends AbstractKubernetesTestResource<KubernetesMockServer> {
 
     @Override
-    public Map<String, String> start() {
-        final Map<String, String> systemProps = new HashMap<>();
-        systemProps.put(Config.KUBERNETES_TRUST_CERT_SYSTEM_PROPERTY, "true");
-        systemProps.put(Config.KUBERNETES_AUTH_TRYKUBECONFIG_SYSTEM_PROPERTY, "false");
-        systemProps.put(Config.KUBERNETES_AUTH_TRYSERVICEACCOUNT_SYSTEM_PROPERTY, "false");
-        systemProps.put(Config.KUBERNETES_NAMESPACE_SYSTEM_PROPERTY, "test");
-        systemProps.put(Config.KUBERNETES_HTTP2_DISABLE, "true");
-
-        mockServer = createMockServer();
-        mockServer.init();
-        try (NamespacedKubernetesClient client = mockServer.createClient()) {
-            systemProps.put(Config.KUBERNETES_MASTER_SYSTEM_PROPERTY, client.getConfiguration().getMasterUrl());
-        }
+    protected GenericKubernetesClient<?> getClient() {
+        return server.createClient();
+    }
 
-        configureMockServer(mockServer);
+    @Override
+    protected void initServer() {
+        server.init();
+    }
 
-        return systemProps;
+    @Override
+    protected KubernetesMockServer createServer() {
+        return createMockServer();
     }
 
+    /**
+     * @deprecated use {@link #createServer()}
+     */
+    @Deprecated
     protected KubernetesMockServer createMockServer() {
         return new KubernetesMockServer(useHttps());
     }
 
+    @Override
+    protected void configureServer() {
+        configureMockServer(server);
+    }
+
     /**
-     * Can be used by subclasses of {@code KubernetesMockServerTestResource} in order to
-     * setup the mock server before the Quarkus application starts
+     * @deprecated use {@link #configureServer()}
      */
+    @Deprecated
     public void configureMockServer(KubernetesMockServer mockServer) {
-
     }
 
     @Override
     public void stop() {
-        if (mockServer != null) {
-            mockServer.destroy();
+        if (server != null) {
+            server.destroy();
+            server = null;
         }
     }
 
     @Override
-    public void inject(Object testInstance) {
-        Class<?> c = testInstance.getClass();
-        while (c != Object.class) {
-            for (Field f : c.getDeclaredFields()) {
-                if (f.getAnnotation(MockServer.class) != null) {
-                    if (!KubernetesMockServer.class.isAssignableFrom(f.getType())) {
-                        throw new RuntimeException("@MockServer can only be used on fields of type KubernetesMockServer");
-                    }
-
-                    f.setAccessible(true);
-                    try {
-                        f.set(testInstance, mockServer);
-                        return;
-                    } catch (Exception e) {
-                        throw new RuntimeException(e);
-                    }
-                }
-            }
-            c = c.getSuperclass();
-        }
+    protected Class<?> getInjectedClass() {
+        return KubernetesMockServer.class;
     }
 
-    protected boolean useHttps() {
-        return Boolean.getBoolean("quarkus.kubernetes-client.test.https");
+    @Override
+    protected Class<? extends Annotation> getInjectionAnnotation() {
+        return MockServer.class;
     }
 }
diff --git a/test-framework/kubernetes-client/src/main/java/io/quarkus/test/kubernetes/client/KubernetesServerTestResource.java b/test-framework/kubernetes-client/src/main/java/io/quarkus/test/kubernetes/client/KubernetesServerTestResource.java
new file mode 100644
index 0000000000000..99b0d893e6800
--- /dev/null
+++ b/test-framework/kubernetes-client/src/main/java/io/quarkus/test/kubernetes/client/KubernetesServerTestResource.java
@@ -0,0 +1,70 @@
+package io.quarkus.test.kubernetes.client;
+
+import java.lang.annotation.Annotation;
+import java.net.InetAddress;
+import java.util.Collections;
+import java.util.function.Consumer;
+
+import io.fabric8.kubernetes.client.GenericKubernetesClient;
+import io.fabric8.kubernetes.client.server.mock.KubernetesServer;
+import io.quarkus.test.common.QuarkusTestResourceConfigurableLifecycleManager;
+
+public class KubernetesServerTestResource extends AbstractKubernetesTestResource<KubernetesServer>
+        implements QuarkusTestResourceConfigurableLifecycleManager<WithKubernetesTestServer> {
+
+    private boolean https = false;
+    private boolean crud = true;
+    private int port = 0;
+    private Consumer<KubernetesServer> setup;
+
+    @Override
+    public void init(WithKubernetesTestServer annotation) {
+        this.https = annotation.https();
+        this.crud = annotation.crud();
+        this.port = annotation.port();
+        try {
+            this.setup = annotation.setup().newInstance();
+        } catch (InstantiationException | IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    protected GenericKubernetesClient<?> getClient() {
+        return server.getClient();
+    }
+
+    @Override
+    protected void initServer() {
+        server.before();
+    }
+
+    @Override
+    protected void configureServer() {
+        if (setup != null)
+            setup.accept(server);
+    }
+
+    @Override
+    protected KubernetesServer createServer() {
+        return new KubernetesServer(https, crud, InetAddress.getLoopbackAddress(), port, Collections.emptyList());
+    }
+
+    @Override
+    public void stop() {
+        if (server != null) {
+            server.after();
+            server = null;
+        }
+    }
+
+    @Override
+    protected Class<?> getInjectedClass() {
+        return KubernetesServer.class;
+    }
+
+    @Override
+    protected Class<? extends Annotation> getInjectionAnnotation() {
+        return KubernetesTestServer.class;
+    }
+}
diff --git a/test-framework/kubernetes-client/src/main/java/io/quarkus/test/kubernetes/client/KubernetesTestServer.java b/test-framework/kubernetes-client/src/main/java/io/quarkus/test/kubernetes/client/KubernetesTestServer.java
new file mode 100644
index 0000000000000..bb78b5413ad6a
--- /dev/null
+++ b/test-framework/kubernetes-client/src/main/java/io/quarkus/test/kubernetes/client/KubernetesTestServer.java
@@ -0,0 +1,18 @@
+package io.quarkus.test.kubernetes.client;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import io.fabric8.kubernetes.client.server.mock.KubernetesServer;
+
+/**
+ * Used to specify that the field should be injected with the mock Kubernetes API server
+ * Can only be used on type {@link KubernetesServer}
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface KubernetesTestServer {
+
+}
diff --git a/test-framework/kubernetes-client/src/main/java/io/quarkus/test/kubernetes/client/WithKubernetesTestServer.java b/test-framework/kubernetes-client/src/main/java/io/quarkus/test/kubernetes/client/WithKubernetesTestServer.java
new file mode 100644
index 0000000000000..c0bf14f1cebec
--- /dev/null
+++ b/test-framework/kubernetes-client/src/main/java/io/quarkus/test/kubernetes/client/WithKubernetesTestServer.java
@@ -0,0 +1,46 @@
+package io.quarkus.test.kubernetes.client;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.function.Consumer;
+
+import io.fabric8.kubernetes.client.server.mock.KubernetesServer;
+import io.quarkus.test.common.QuarkusTestResource;
+
+/**
+ * Use on your test resource to get a mock {@link KubernetesServer} spawn up, and injectable with {@link KubernetesTestServer}.
+ * This annotation is only active when used on a test class, and only for this test class.
+ */
+@QuarkusTestResource(value = KubernetesServerTestResource.class, restrictToAnnotatedClass = true)
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface WithKubernetesTestServer {
+
+    /**
+     * Start it with HTTPS
+     */
+    boolean https() default false;
+
+    /**
+     * Start it in CRUD mode
+     */
+    boolean crud() default true;
+
+    /**
+     * Port to use, defaults to any available port
+     */
+    int port() default 0;
+
+    /**
+     * Setup class to call after the mock server is created, for custom setup.
+     */
+    Class<? extends Consumer<KubernetesServer>> setup() default NO_SETUP.class;
+
+    static class NO_SETUP implements Consumer<KubernetesServer> {
+        @Override
+        public void accept(KubernetesServer t) {
+        }
+    };
+}