$ kubectl create --help
Create a resource from a file or from stdin.
 
 JSON and YAML formats are accepted.
 
Examples:
  # Create a pod using the data in pod.json
  kubectl create -f ./pod.json
 
  # Create a pod based on the JSON passed into stdin
  cat pod.json | kubectl create -f -
 
  # Edit the data in registry.yaml in JSON then create the resource using the edited data
  kubectl create -f registry.yaml --edit -o json
 
Available Commands:
  clusterrole           Create a cluster role
  clusterrolebinding    Create a cluster role binding for a particular cluster role
  configmap             Create a config map from a local file, directory or literal value
  cronjob               Create a cron job with the specified name
  deployment            Create a deployment with the specified name
  ingress               Create an ingress with the specified name
  job                   Create a job with the specified name
  namespace             Cria a namespace com um nome especificado
  poddisruptionbudget   Create a pod disruption budget with the specified name
  priorityclass         Create a priority class with the specified name
  quota                 Create a quota with the specified name
  role                  Create a role with single rule
  rolebinding           Create a role binding for a particular role or cluster role
  secret                Cria um secret utilizando um sub-comando especificado
  service               Create a service using a specified subcommand
  serviceaccount        Cria uma conta de serviço com um nome especificado
  token                 Request a service account token
 
Options:
    --allow-missing-template-keys=true:
 If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to
 golang and jsonpath output formats.
 
    --dry-run='none':
 Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without
 sending it. If server strategy, submit server-side request without persisting the resource.
 
    --edit=false:
 Edit the API resource before creating
 
    --field-manager='kubectl-create':
 Name of the manager used to track field ownership.
 
    -f, --filename=[]:
 Filename, directory, or URL to files to use to create the resource
 
    -k, --kustomize='':
 Process the kustomization directory. This flag can't be used together with -f or -R.
 
    -o, --output='':
 Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath,
 jsonpath-as-json, jsonpath-file).
 
    --raw='':
 Raw URI to POST to the server.  Uses the transport specified by the kubeconfig file.
 
    -R, --recursive=false:
 Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests
 organized within the same directory.
 
    --save-config=false:
 If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will
 be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future.
 
    -l, --selector='':
 Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching
 objects must satisfy all of the specified label constraints.
 
    --show-managed-fields=false:
 If true, keep the managedFields when printing objects in JSON or YAML format.
 
    --template='':
 Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format
 is golang templates [http://golang.org/pkg/text/template/#pkg-overview].
 
    --validate='strict':
 Must be one of: strict (or true), warn, ignore (or false).    "true" or "strict" will use a schema to validate
 the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation
 is enabled on the api-server, but will fall back to less reliable client-side validation if not.    "warn" will
 warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled
 on the API server, and behave as "ignore" otherwise.   "false" or "ignore" will not perform any schema
 validation, silently dropping any unknown or duplicate fields.
 
    --windows-line-endings=false:
 Only relevant if --edit=true. Defaults to the line ending native to your platform.
 
Usage:
  kubectl create -f FILENAME [options]
 
Use "kubectl <command> --help" for more information about a given command.
Use "kubectl options" for a list of global command-line options (applies to all commands).

$ kubectl create namespace ns-system --dry-run=client -o yaml > ns.yaml

ns.yaml

apiVersion: v1
kind: Namespace
metadata:
  creationTimestamp: null
  name: ns-system
spec: {}
status: {}

$ kubectl create -f ns.yaml
namespace/ns-system created

secret-app

POSTGRES_USER=zabbix
POSTGRES_PASSWORD=zabbix

$ kubectl create secret generic secret-app -n ns-system --from-env-file=secret-app -o yaml --dry-run=client > secret-app.yaml

secret-app.yaml

apiVersion: v1
data:
  POSTGRES_PASSWORD: emFiYml4
  POSTGRES_USER: emFiYml4
kind: Secret
metadata:
  creationTimestamp: null
  name: secret-app
  namespace: ns-system

$ kubectl create -f secret-app.yaml
secret/secret-app created

$ kubectl create configmap cm-app --from-literal ENABLE_TIMESCALEDB=true -o yaml --dry-run=client > cm-app.yaml

cm-app.yaml

apiVersion: v1
data:
  ENABLE_TIMESCALEDB: "true"
kind: ConfigMap
metadata:
  creationTimestamp: null
  name: cm-app

$ kubectl create -f cm-app.yaml
configmap/cm-app created

$ kubectl create deployment pgsql-server -n ns-system --image=postgres --port=5432 > --dry-run=client -o yaml > deploy-pgsql.yaml

deploy-pgsql.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: "2022-06-23T20:26:59Z"
  generation: 1
  labels:
    app: pgsql-server
  name: pgsql-server
  namespace: ns-system
  resourceVersion: "8137164"
  uid: a3086bc8-6869-42a5-81f8-28e9738c86cf
spec:
  progressDeadlineSeconds: 600
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: pgsql-server
  strategy:
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 25%
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: pgsql-server
    spec:
      containers:
      - image: postgres
        imagePullPolicy: Always
        name: postgres
        ports:
        - containerPort: 5432
          protocol: TCP
        resources: {}
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      terminationGracePeriodSeconds: 30
status: {}

$ kubectl create -f deploy-pgsql.yaml
deployment.apps/pgsql-server created

$ kubectl expose deploy pgsql-server --port=5432 --target-port=5432 --type=ClusterIP -n ns-system --dry-run=client -o yaml > svc-app.yaml

svc-app.yaml

apiVersion: v1
kind: Service
metadata:
  creationTimestamp: null
  labels:
    app: pgsql-server
  name: pgsql-server
  namespace: ns-system
spec:
  ports:
  - port: 5432
    protocol: TCP
    targetPort: 5432
  selector:
    app: pgsql-server
  type: ClusterIP
status:
  loadBalancer: {}