0
# Core Resources (core/v1)
1

2
The Core API group provides fundamental Kubernetes resources for workload management, configuration storage, and cluster operations. These resources form the foundation of most Kubernetes applications.
3

4
## Package Import
5

6
```typescript { .api }
7
import { core } from "@pulumi/kubernetes";
8
import * as k8s from "@pulumi/kubernetes";
9

10
// Direct core imports
11
import { Pod, Service, ConfigMap, Secret, Namespace } from "@pulumi/kubernetes/core/v1";
12
```
13

14
## Pod
15

16
Pod is a collection of containers that can run on a host. This resource is created by clients and scheduled onto hosts.
17

18
```typescript { .api }
19
class Pod extends pulumi.CustomResource {
20
    constructor(name: string, args?: PodArgs, opts?: pulumi.CustomResourceOptions)
21
    
22
    public static get(name: string, id: pulumi.Input<pulumi.ID>, opts?: pulumi.CustomResourceOptions): Pod
23
    
24
    // Output properties
25
    public readonly apiVersion!: pulumi.Output<"v1">;
26
    public readonly kind!: pulumi.Output<"Pod">;
27
    public readonly metadata!: pulumi.Output<outputs.meta.v1.ObjectMeta>;
28
    public readonly spec!: pulumi.Output<outputs.core.v1.PodSpec>;
29
    public readonly status!: pulumi.Output<outputs.core.v1.PodStatus>;
30
}
31

32
interface PodArgs {
33
    apiVersion?: pulumi.Input<"v1">;
34
    kind?: pulumi.Input<"Pod">;
35
    metadata?: pulumi.Input<inputs.meta.v1.ObjectMeta>;
36
    spec?: pulumi.Input<inputs.core.v1.PodSpec>;
37
}
38
```
39

40
### Pod Lifecycle Management
41

42
The Pod resource waits until its status is ready before registering success for create/update:
43

44
1. The Pod is scheduled ("PodScheduled" condition is true)
45
2. The Pod is initialized ("Initialized" condition is true)  
46
3. The Pod is ready ("Ready" condition is true) and phase is "Running"
47
4. Or (for Jobs): The Pod succeeded (phase set to "Succeeded")
48

49
Default timeout is 10 minutes, configurable via `customTimeouts` option.
50

51
### Pod Usage Examples
52

53
```typescript { .api }
54
// Basic pod with auto-naming
55
const pod = new k8s.core.v1.Pod("nginx-pod", {
56
    spec: {
57
        containers: [{
58
            name: "nginx",
59
            image: "nginx:1.21",
60
            ports: [{
61
                containerPort: 80,
62
            }],
63
        }],
64
    },
65
});
66

67
// Pod with explicit name and configuration
68
const configuredPod = new k8s.core.v1.Pod("web-server", {
69
    metadata: {
70
        name: "web-server",
71
        labels: {
72
            app: "web",
73
            tier: "frontend",
74
        },
75
    },
76
    spec: {
77
        containers: [{
78
            name: "nginx",
79
            image: "nginx:1.21",
80
            ports: [{
81
                containerPort: 80,
82
                protocol: "TCP",
83
            }],
84
            env: [{
85
                name: "ENV_VAR",
86
                value: "production",
87
            }],
88
            resources: {
89
                requests: {
90
                    cpu: "100m",
91
                    memory: "128Mi",
92
                },
93
                limits: {
94
                    cpu: "500m",
95
                    memory: "512Mi",
96
                },
97
            },
98
        }],
99
        restartPolicy: "Always",
100
    },
101
});
102
```
103

104
## Service
105

106
Service is a named abstraction of software service consisting of local port that the proxy listens on, and the selector that determines which pods will answer requests sent through the proxy.
107

108
```typescript { .api }
109
class Service extends pulumi.CustomResource {
110
    constructor(name: string, args?: ServiceArgs, opts?: pulumi.CustomResourceOptions)
111
    
112
    public static get(name: string, id: pulumi.Input<pulumi.ID>, opts?: pulumi.CustomResourceOptions): Service
113
    
114
    // Output properties
115
    public readonly apiVersion!: pulumi.Output<"v1">;
116
    public readonly kind!: pulumi.Output<"Service">;
117
    public readonly metadata!: pulumi.Output<outputs.meta.v1.ObjectMeta>;
118
    public readonly spec!: pulumi.Output<outputs.core.v1.ServiceSpec>;
119
    public readonly status!: pulumi.Output<outputs.core.v1.ServiceStatus>;
120
}
121

122
interface ServiceArgs {
123
    apiVersion?: pulumi.Input<"v1">;
124
    kind?: pulumi.Input<"Service">;
125
    metadata?: pulumi.Input<inputs.meta.v1.ObjectMeta>;
126
    spec?: pulumi.Input<inputs.core.v1.ServiceSpec>;
127
}
128
```
129

130
### Service Types
131

132
```typescript { .api }
133
// Service type enumeration
134
type ServiceType = "ClusterIP" | "NodePort" | "LoadBalancer" | "ExternalName";
135

136
// Session affinity options
137
type SessionAffinity = "ClientIP" | "None";
138
```
139

140
### Service Usage Examples
141

142
```typescript { .api }
143
// ClusterIP service (default)
144
const clusterService = new k8s.core.v1.Service("app-service", {
145
    spec: {
146
        selector: {
147
            app: "my-app",
148
        },
149
        ports: [{
150
            port: 80,
151
            targetPort: 8080,
152
            protocol: "TCP",
153
        }],
154
        type: "ClusterIP",
155
    },
156
});
157

158
// LoadBalancer service
159
const loadBalancerService = new k8s.core.v1.Service("lb-service", {
160
    spec: {
161
        selector: {
162
            app: "web-app",
163
        },
164
        ports: [{
165
            port: 80,
166
            targetPort: 80,
167
            protocol: "TCP",
168
        }, {
169
            port: 443,
170
            targetPort: 443,
171
            protocol: "TCP",
172
        }],
173
        type: "LoadBalancer",
174
    },
175
});
176

177
// NodePort service
178
const nodePortService = new k8s.core.v1.Service("nodeport-service", {
179
    spec: {
180
        selector: {
181
            app: "api",
182
        },
183
        ports: [{
184
            port: 3000,
185
            targetPort: 3000,
186
            nodePort: 30000,
187
            protocol: "TCP",
188
        }],
189
        type: "NodePort",
190
    },
191
});
192
```
193

194
## ConfigMap
195

196
ConfigMap holds configuration data for pods to consume.
197

198
```typescript { .api }
199
class ConfigMap extends pulumi.CustomResource {
200
    constructor(name: string, args?: ConfigMapArgs, opts?: pulumi.CustomResourceOptions)
201
    
202
    public static get(name: string, id: pulumi.Input<pulumi.ID>, opts?: pulumi.CustomResourceOptions): ConfigMap
203
    
204
    // Output properties
205
    public readonly apiVersion!: pulumi.Output<"v1">;
206
    public readonly kind!: pulumi.Output<"ConfigMap">;
207
    public readonly metadata!: pulumi.Output<outputs.meta.v1.ObjectMeta>;
208
    public readonly binaryData!: pulumi.Output<{[key: string]: string}>;
209
    public readonly data!: pulumi.Output<{[key: string]: string}>;
210
    public readonly immutable!: pulumi.Output<boolean>;
211
}
212

213
interface ConfigMapArgs {
214
    apiVersion?: pulumi.Input<"v1">;
215
    kind?: pulumi.Input<"ConfigMap">;
216
    metadata?: pulumi.Input<inputs.meta.v1.ObjectMeta>;
217
    binaryData?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
218
    data?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
219
    immutable?: pulumi.Input<boolean>;
220
}
221
```
222

223
### ConfigMap Usage Examples
224

225
```typescript { .api }
226
// Basic configuration data
227
const appConfig = new k8s.core.v1.ConfigMap("app-config", {
228
    data: {
229
        "database.url": "postgresql://localhost:5432/mydb",
230
        "redis.host": "redis-service",
231
        "app.env": "production",
232
        "feature.flags": JSON.stringify({
233
            enableNewFeature: true,
234
            debugMode: false,
235
        }),
236
    },
237
});
238

239
// Configuration from file content
240
const configFile = new k8s.core.v1.ConfigMap("nginx-config", {
241
    data: {
242
        "nginx.conf": `
243
user nginx;
244
worker_processes auto;
245
error_log /var/log/nginx/error.log warn;
246
pid /var/run/nginx.pid;
247

248
events {
249
    worker_connections 1024;
250
}
251

252
http {
253
    include /etc/nginx/mime.types;
254
    default_type application/octet-stream;
255
    
256
    server {
257
        listen 80;
258
        server_name localhost;
259
        
260
        location / {
261
            root /usr/share/nginx/html;
262
            index index.html;
263
        }
264
    }
265
}`,
266
    },
267
});
268

269
// Immutable ConfigMap for better performance
270
const immutableConfig = new k8s.core.v1.ConfigMap("static-config", {
271
    immutable: true,
272
    data: {
273
        "version": "1.2.3",
274
        "build": "20231201-1500",
275
    },
276
});
277
```
278

279
## Secret
280

281
Secret holds secret data of a certain type. The total bytes of the values in the Data field must be less than MaxSecretSize bytes.
282

283
```typescript { .api }
284
class Secret extends pulumi.CustomResource {
285
    constructor(name: string, args?: SecretArgs, opts?: pulumi.CustomResourceOptions)
286
    
287
    public static get(name: string, id: pulumi.Input<pulumi.ID>, opts?: pulumi.CustomResourceOptions): Secret
288
    
289
    // Output properties
290
    public readonly apiVersion!: pulumi.Output<"v1">;
291
    public readonly kind!: pulumi.Output<"Secret">;
292
    public readonly metadata!: pulumi.Output<outputs.meta.v1.ObjectMeta>;
293
    public readonly data!: pulumi.Output<{[key: string]: string}>;
294
    public readonly immutable!: pulumi.Output<boolean>;
295
    public readonly stringData!: pulumi.Output<{[key: string]: string}>;
296
    public readonly type!: pulumi.Output<string>;
297
}
298

299
interface SecretArgs {
300
    apiVersion?: pulumi.Input<"v1">;
301
    kind?: pulumi.Input<"Secret">;
302
    metadata?: pulumi.Input<inputs.meta.v1.ObjectMeta>;
303
    data?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
304
    immutable?: pulumi.Input<boolean>;
305
    stringData?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
306
    type?: pulumi.Input<string>;
307
}
308
```
309

310
### Secret Types
311

312
```typescript { .api }
313
// Common secret types
314
type SecretType = 
315
    | "Opaque"                                    // Default arbitrary user-defined data
316
    | "kubernetes.io/service-account-token"       // Service account token
317
    | "kubernetes.io/dockercfg"                   // Dockercfg file
318
    | "kubernetes.io/dockerconfigjson"            // Docker config.json file
319
    | "kubernetes.io/basic-auth"                  // Basic authentication credentials
320
    | "kubernetes.io/ssh-auth"                    // SSH authentication credentials
321
    | "kubernetes.io/tls"                         // TLS certificate and key
322
    | "bootstrap.kubernetes.io/token";            // Bootstrap token
323
```
324

325
### Secret Usage Examples
326

327
```typescript { .api }
328
// Basic opaque secret
329
const dbSecret = new k8s.core.v1.Secret("db-credentials", {
330
    type: "Opaque",
331
    stringData: {
332
        username: "admin",
333
        password: "super-secret-password",
334
        host: "database.example.com",
335
        port: "5432",
336
    },
337
});
338

339
// TLS certificate secret
340
const tlsSecret = new k8s.core.v1.Secret("tls-cert", {
341
    type: "kubernetes.io/tls",
342
    stringData: {
343
        "tls.crt": "-----BEGIN CERTIFICATE-----\n...",
344
        "tls.key": "-----BEGIN PRIVATE KEY-----\n...",
345
    },
346
});
347

348
// Docker registry secret
349
const dockerSecret = new k8s.core.v1.Secret("docker-registry", {
350
    type: "kubernetes.io/dockerconfigjson",
351
    stringData: {
352
        ".dockerconfigjson": JSON.stringify({
353
            auths: {
354
                "https://index.docker.io/v1/": {
355
                    username: "myuser",
356
                    password: "mypassword",
357
                    email: "myuser@example.com",
358
                    auth: Buffer.from("myuser:mypassword").toString("base64"),
359
                },
360
            },
361
        }),
362
    },
363
});
364

365
// SSH authentication secret
366
const sshSecret = new k8s.core.v1.Secret("ssh-key", {
367
    type: "kubernetes.io/ssh-auth",
368
    stringData: {
369
        "ssh-privatekey": "-----BEGIN OPENSSH PRIVATE KEY-----\n...",
370
    },
371
});
372
```
373

374
## Namespace
375

376
Namespace provides a mechanism for isolating groups of resources within a single cluster.
377

378
```typescript { .api }
379
class Namespace extends pulumi.CustomResource {
380
    constructor(name: string, args?: NamespaceArgs, opts?: pulumi.CustomResourceOptions)
381
    
382
    public static get(name: string, id: pulumi.Input<pulumi.ID>, opts?: pulumi.CustomResourceOptions): Namespace
383
    
384
    // Output properties
385
    public readonly apiVersion!: pulumi.Output<"v1">;
386
    public readonly kind!: pulumi.Output<"Namespace">;
387
    public readonly metadata!: pulumi.Output<outputs.meta.v1.ObjectMeta>;
388
    public readonly spec!: pulumi.Output<outputs.core.v1.NamespaceSpec>;
389
    public readonly status!: pulumi.Output<outputs.core.v1.NamespaceStatus>;
390
}
391

392
interface NamespaceArgs {
393
    apiVersion?: pulumi.Input<"v1">;
394
    kind?: pulumi.Input<"Namespace">;
395
    metadata?: pulumi.Input<inputs.meta.v1.ObjectMeta>;
396
    spec?: pulumi.Input<inputs.core.v1.NamespaceSpec>;
397
}
398
```
399

400
### Namespace Usage Examples
401

402
```typescript { .api }
403
// Basic namespace
404
const appNamespace = new k8s.core.v1.Namespace("app-namespace", {
405
    metadata: {
406
        name: "my-application",
407
        labels: {
408
            environment: "production",
409
            team: "backend",
410
        },
411
    },
412
});
413

414
// Namespace with resource quotas and labels
415
const devNamespace = new k8s.core.v1.Namespace("development", {
416
    metadata: {
417
        name: "development",
418
        labels: {
419
            environment: "dev",
420
            "pod-security.kubernetes.io/enforce": "baseline",
421
            "pod-security.kubernetes.io/audit": "restricted",
422
            "pod-security.kubernetes.io/warn": "restricted",
423
        },
424
        annotations: {
425
            "description": "Development environment namespace",
426
            "contact": "dev-team@example.com",
427
        },
428
    },
429
});
430
```
431

432
## PersistentVolume
433

434
PersistentVolume (PV) is a piece of storage in the cluster that has been provisioned by an administrator or dynamically provisioned using Storage Classes.
435

436
```typescript { .api }
437
class PersistentVolume extends pulumi.CustomResource {
438
    constructor(name: string, args?: PersistentVolumeArgs, opts?: pulumi.CustomResourceOptions)
439
    
440
    public static get(name: string, id: pulumi.Input<pulumi.ID>, opts?: pulumi.CustomResourceOptions): PersistentVolume
441
    
442
    // Output properties
443
    public readonly apiVersion!: pulumi.Output<"v1">;
444
    public readonly kind!: pulumi.Output<"PersistentVolume">;
445
    public readonly metadata!: pulumi.Output<outputs.meta.v1.ObjectMeta>;
446
    public readonly spec!: pulumi.Output<outputs.core.v1.PersistentVolumeSpec>;
447
    public readonly status!: pulumi.Output<outputs.core.v1.PersistentVolumeStatus>;
448
}
449

450
interface PersistentVolumeArgs {
451
    apiVersion?: pulumi.Input<"v1">;
452
    kind?: pulumi.Input<"PersistentVolume">;
453
    metadata?: pulumi.Input<inputs.meta.v1.ObjectMeta>;
454
    spec?: pulumi.Input<inputs.core.v1.PersistentVolumeSpec>;
455
}
456
```
457

458
## PersistentVolumeClaim
459

460
PersistentVolumeClaim (PVC) is a request for storage by a user.
461

462
```typescript { .api }
463
class PersistentVolumeClaim extends pulumi.CustomResource {
464
    constructor(name: string, args?: PersistentVolumeClaimArgs, opts?: pulumi.CustomResourceOptions)
465
    
466
    public static get(name: string, id: pulumi.Input<pulumi.ID>, opts?: pulumi.CustomResourceOptions): PersistentVolumeClaim
467
    
468
    // Output properties
469
    public readonly apiVersion!: pulumi.Output<"v1">;
470
    public readonly kind!: pulumi.Output<"PersistentVolumeClaim">;
471
    public readonly metadata!: pulumi.Output<outputs.meta.v1.ObjectMeta>;
472
    public readonly spec!: pulumi.Output<outputs.core.v1.PersistentVolumeClaimSpec>;
473
    public readonly status!: pulumi.Output<outputs.core.v1.PersistentVolumeClaimStatus>;
474
}
475

476
interface PersistentVolumeClaimArgs {
477
    apiVersion?: pulumi.Input<"v1">;
478
    kind?: pulumi.Input<"PersistentVolumeClaim">;
479
    metadata?: pulumi.Input<inputs.meta.v1.ObjectMeta>;
480
    spec?: pulumi.Input<inputs.core.v1.PersistentVolumeClaimSpec>;
481
}
482
```
483

484
### Storage Usage Examples
485

486
```typescript { .api }
487
// PersistentVolumeClaim for database storage
488
const dbStorage = new k8s.core.v1.PersistentVolumeClaim("db-storage", {
489
    spec: {
490
        accessModes: ["ReadWriteOnce"],
491
        storageClassName: "fast-ssd",
492
        resources: {
493
            requests: {
494
                storage: "10Gi",
495
            },
496
        },
497
    },
498
});
499

500
// Static PersistentVolume
501
const staticPv = new k8s.core.v1.PersistentVolume("static-pv", {
502
    spec: {
503
        capacity: {
504
            storage: "5Gi",
505
        },
506
        accessModes: ["ReadWriteOnce"],
507
        persistentVolumeReclaimPolicy: "Retain",
508
        hostPath: {
509
            path: "/data/static",
510
        },
511
    },
512
});
513
```
514

515
## ServiceAccount
516

517
ServiceAccount binds together a name, a principal that can be authenticated and authorized, and a set of secrets.
518

519
```typescript { .api }
520
class ServiceAccount extends pulumi.CustomResource {
521
    constructor(name: string, args?: ServiceAccountArgs, opts?: pulumi.CustomResourceOptions)
522
    
523
    public static get(name: string, id: pulumi.Input<pulumi.ID>, opts?: pulumi.CustomResourceOptions): ServiceAccount
524
    
525
    // Output properties
526
    public readonly apiVersion!: pulumi.Output<"v1">;
527
    public readonly kind!: pulumi.Output<"ServiceAccount">;
528
    public readonly metadata!: pulumi.Output<outputs.meta.v1.ObjectMeta>;
529
    public readonly automountServiceAccountToken!: pulumi.Output<boolean>;
530
    public readonly imagePullSecrets!: pulumi.Output<outputs.core.v1.LocalObjectReference[]>;
531
    public readonly secrets!: pulumi.Output<outputs.core.v1.ObjectReference[]>;
532
}
533

534
interface ServiceAccountArgs {
535
    apiVersion?: pulumi.Input<"v1">;
536
    kind?: pulumi.Input<"ServiceAccount">;
537
    metadata?: pulumi.Input<inputs.meta.v1.ObjectMeta>;
538
    automountServiceAccountToken?: pulumi.Input<boolean>;
539
    imagePullSecrets?: pulumi.Input<pulumi.Input<inputs.core.v1.LocalObjectReference>[]>;
540
    secrets?: pulumi.Input<pulumi.Input<inputs.core.v1.ObjectReference>[]>;
541
}
542
```
543

544
### ServiceAccount Usage Examples
545

546
```typescript { .api }
547
// Basic service account
548
const appServiceAccount = new k8s.core.v1.ServiceAccount("app-sa", {
549
    metadata: {
550
        name: "my-app-service-account",
551
        annotations: {
552
            "eks.amazonaws.com/role-arn": "arn:aws:iam::123456789012:role/MyAppRole",
553
        },
554
    },
555
});
556

557
// Service account with image pull secrets
558
const serviceAccountWithSecrets = new k8s.core.v1.ServiceAccount("sa-with-secrets", {
559
    imagePullSecrets: [{
560
        name: "docker-registry-secret",
561
    }],
562
    automountServiceAccountToken: false,
563
});
564
```
565

566
## Additional Core Resources
567

568
### Endpoints
569

570
Endpoints is a collection of endpoints that implement the actual service.
571

572
```typescript { .api }
573
class Endpoints extends pulumi.CustomResource {
574
    constructor(name: string, args?: EndpointsArgs, opts?: pulumi.CustomResourceOptions)
575
    
576
    // Output properties
577
    public readonly apiVersion!: pulumi.Output<"v1">;
578
    public readonly kind!: pulumi.Output<"Endpoints">;
579
    public readonly metadata!: pulumi.Output<outputs.meta.v1.ObjectMeta>;
580
    public readonly subsets!: pulumi.Output<outputs.core.v1.EndpointSubset[]>;
581
}
582
```
583

584
### Event
585

586
Event is a report of an event somewhere in the cluster.
587

588
```typescript { .api }
589
class Event extends pulumi.CustomResource {
590
    constructor(name: string, args?: EventArgs, opts?: pulumi.CustomResourceOptions)
591
    
592
    // Output properties
593
    public readonly apiVersion!: pulumi.Output<"v1">;
594
    public readonly kind!: pulumi.Output<"Event">;
595
    public readonly metadata!: pulumi.Output<outputs.meta.v1.ObjectMeta>;
596
    public readonly action!: pulumi.Output<string>;
597
    public readonly count!: pulumi.Output<number>;
598
    public readonly eventTime!: pulumi.Output<string>;
599
    public readonly firstTimestamp!: pulumi.Output<string>;
600
    public readonly lastTimestamp!: pulumi.Output<string>;
601
    public readonly message!: pulumi.Output<string>;
602
    public readonly reason!: pulumi.Output<string>;
603
    public readonly type!: pulumi.Output<string>;
604
}
605
```
606

607
### LimitRange
608

609
LimitRange sets resource usage limits for objects in a namespace.
610

611
```typescript { .api }
612
class LimitRange extends pulumi.CustomResource {
613
    constructor(name: string, args?: LimitRangeArgs, opts?: pulumi.CustomResourceOptions)
614
    
615
    // Output properties
616
    public readonly apiVersion!: pulumi.Output<"v1">;
617
    public readonly kind!: pulumi.Output<"LimitRange">;
618
    public readonly metadata!: pulumi.Output<outputs.meta.v1.ObjectMeta>;
619
    public readonly spec!: pulumi.Output<outputs.core.v1.LimitRangeSpec>;
620
}
621
```
622

623
### ResourceQuota
624

625
ResourceQuota sets aggregate quota restrictions enforced per namespace.
626

627
```typescript { .api }
628
class ResourceQuota extends pulumi.CustomResource {
629
    constructor(name: string, args?: ResourceQuotaArgs, opts?: pulumi.CustomResourceOptions)
630
    
631
    // Output properties
632
    public readonly apiVersion!: pulumi.Output<"v1">;
633
    public readonly kind!: pulumi.Output<"ResourceQuota">;
634
    public readonly metadata!: pulumi.Output<outputs.meta.v1.ObjectMeta>;
635
    public readonly spec!: pulumi.Output<outputs.core.v1.ResourceQuotaSpec>;
636
    public readonly status!: pulumi.Output<outputs.core.v1.ResourceQuotaStatus>;
637
}
638
```
639

640
### ResourceQuota and LimitRange Usage Examples
641

642
```typescript { .api }
643
// Resource quota for namespace
644
const namespaceQuota = new k8s.core.v1.ResourceQuota("namespace-quota", {
645
    spec: {
646
        hard: {
647
            "requests.cpu": "4",
648
            "requests.memory": "8Gi",
649
            "limits.cpu": "8", 
650
            "limits.memory": "16Gi",
651
            "pods": "10",
652
            "persistentvolumeclaims": "4",
653
        },
654
    },
655
});
656

657
// Limit range for containers
658
const containerLimits = new k8s.core.v1.LimitRange("container-limits", {
659
    spec: {
660
        limits: [{
661
            type: "Container",
662
            default: {
663
                cpu: "500m",
664
                memory: "512Mi",
665
            },
666
            defaultRequest: {
667
                cpu: "100m",
668
                memory: "128Mi",
669
            },
670
            max: {
671
                cpu: "2",
672
                memory: "2Gi",
673
            },
674
            min: {
675
                cpu: "50m",
676
                memory: "64Mi",
677
            },
678
        }],
679
    },
680
});
681
```
682

683
## Resource Variants
684

685
All core resources include the following variants:
686

687
### List Resources
688
For batch operations and collection management:
689
- `PodList`, `ServiceList`, `ConfigMapList`, `SecretList`, etc.
690

691
### Patch Resources  
692
For strategic merge patch operations:
693
- `PodPatch`, `ServicePatch`, `ConfigMapPatch`, `SecretPatch`, etc.
694

695
```typescript { .api }
696
// Example patch operation
697
const podPatch = new k8s.core.v1.PodPatch("pod-update", {
698
    metadata: {
699
        name: "existing-pod",
700
        labels: {
701
            "updated": "true",
702
        },
703
    },
704
    spec: {
705
        containers: [{
706
            name: "nginx",
707
            image: "nginx:1.22", // Update image version
708
        }],
709
    },
710
});
711
```
712

713
The Core v1 API group provides the essential building blocks for any Kubernetes application, offering type-safe resource management with comprehensive lifecycle control and configuration options.