docs.openshift.com
Open in
urlscan Pro
34.233.250.155
Public Scan
URL:
https://docs.openshift.com/container-platform/4.5/welcome/index.html
Submission: On November 29 via api from SG — Scanned from DE
Submission: On November 29 via api from SG — Scanned from DE
Form analysis 0 forms found in the DOM
Text Content
* Products
OVERVIEW
* Features
* Pricing
FEATURED PRODUCTS
* Red Hat OpenShift Container Platform
Build, deploy and manage your applications across cloud- and on-premise
infrastructure
* Red Hat OpenShift Dedicated
Single-tenant, high-availability Kubernetes clusters in the public cloud
* Red Hat OpenShift Online
The fastest way for developers to build, host and scale applications in
the public cloud
* All products
* Learn
LEARN
* What is OpenShift
* Get started
* Partners
* Customer success stories
* Blog
* Resources
TECHNOLOGY TOPICS
* Knative
* Security
* Kubernetes
* Service Brokers
* Community
* OpenShift Commons
* Open Source (OKD)
* Startups
* Grants
* Support
* Help Center
* OpenShift Docs
* Free Trial
* Log In
You are viewing documentation for a release that is no longer maintained.
The latest supported version of version 3 is [3.11]. For the most recent
version 4, see [4].
1. Documentation
2. OpenShift Container Platform 4.11 4.10 4.9 4.8 4.7 4.6 4.5 4.4 4.3 4.2 4.1
3.11 3.10 3.9 3.7 3.6 3.5 3.4 3.3 3.2 3.1 3.0
3. About
4. Welcome
history
* About
* Welcome
* About OpenShift Kubernetes Engine
* Legal notice
* Release notes
* OpenShift Container Platform 4.5 release notes
* Versioning policy
* Architecture
* Product architecture
* Installation and update
* The control plane
* Understanding OpenShift development
* Red Hat Enterprise Linux CoreOS
* The CI/CD methodology and practice
* Using ArgoCD
* Admission plug-ins
* Installing
* Mirroring images for a disconnected installation
* Installing on AWS
* Configuring an AWS account
* Manually creating IAM
* Installing a cluster quickly on AWS
* Installing a cluster on AWS with customizations
* Installing a cluster on AWS with network customizations
* Installing a cluster on AWS in a restricted network
* Installing a cluster on AWS into an existing VPC
* Installing a private cluster on AWS
* Installing a cluster on AWS using CloudFormation templates
* Installing a cluster on AWS in a restricted network with user-provisioned
infrastructure
* Uninstalling a cluster on AWS
* Installing on Azure
* Configuring an Azure account
* Manually creating IAM
* Installing a cluster quickly on Azure
* Installing a cluster on Azure with customizations
* Installing a cluster on Azure with network customizations
* Installing a cluster on Azure into an existing VNet
* Installing a private cluster on Azure
* Installing a cluster on Azure using ARM templates
* Uninstalling a cluster on Azure
* Installing on GCP
* Configuring a GCP project
* Manually creating IAM
* Installing a cluster quickly on GCP
* Installing a cluster on GCP with customizations
* Installing a cluster on GCP with network customizations
* Installing a cluster on GCP in a restricted network
* Installing a cluster on GCP into an existing VPC
* Installing a private cluster on GCP
* Installing a cluster on GCP using Deployment Manager templates
* Installing a cluster on GCP using Deployment Manager templates and a
shared VPC
* Installing a cluster on GCP in a restricted network with user-provisioned
infrastructure
* Uninstalling a cluster on GCP
* Installing on bare metal
* Installing a cluster on bare metal
* Installing a cluster on bare metal with network customizations
* Restricted network bare metal installation
* Installing on IBM Z and LinuxONE
* Installing a cluster on IBM Z and LinuxONE
* Restricted network IBM Z installation
* Installing on IBM Power
* Installing a cluster on IBM Power
* Restricted network IBM Power installation
* Installing on OpenStack
* Installing a cluster on OpenStack with customizations
* Installing a cluster on OpenStack with Kuryr
* Installing a cluster on OpenStack on your own infrastructure
* Installing a cluster on OpenStack with Kuryr on your own infrastructure
* Installing a cluster on OpenStack in a restricted network
* Uninstalling a cluster on OpenStack
* Uninstalling a cluster on OpenStack from your own infrastructure
* Installing on RHV
* Installing a cluster quickly on RHV
* Installing a cluster on RHV with customizations
* Uninstalling a cluster on RHV
* Installing on vSphere
* Installing a cluster on vSphere
* Installing a cluster on vSphere with customizations
* Installing a cluster on vSphere with network customizations
* Installing a cluster on vSphere with user-provisioned infrastructure
* Installing a cluster on vSphere with user-provisioned infrastructure and
network customizations
* Installing a cluster on vSphere in a restricted network
* Installing a cluster on vSphere in a restricted network with
user-provisioned infrastructure
* Uninstalling a cluster on vSphere that uses installer-provisioned
infrastructure
* Installation configuration
* Supported installation methods for different platforms
* Customizing nodes
* Available cluster customizations
* Configuring your firewall
* Configuring a private cluster
* Troubleshooting installation issues
* Support for FIPS cryptography
* Updating clusters
* Updating a cluster between minor versions
* Updating a cluster within a minor version from the web console
* Updating a cluster within a minor version by using the CLI
* Updating a cluster that includes RHEL compute machines
* Updating a restricted network cluster
* Post-installation configuration
* Cluster tasks
* Node tasks
* Network configuration
* Storage configuration
* Preparing for users
* Support
* Getting support
* Remote health monitoring with connected clusters
* About remote health monitoring
* Showing data collected by remote health monitoring
* Opting out of remote health reporting
* Using Insights to identify issues with your cluster
* Gathering data about your cluster
* Summarizing cluster specifications
* Troubleshooting
* Troubleshooting installations
* Verifying node health
* Troubleshooting CRI-O container runtime issues
* Troubleshooting Operator issues
* Investigating pod issues
* Troubleshooting the Source-to-Image process
* Troubleshooting storage issues
* Diagnosing OpenShift CLI (oc) issues
* Web console
* Accessing the web console
* Viewing cluster information
* Configuring the web console
* Customizing the web console
* Developer perspective
* Web terminal
* Disabling the web console
* Security
* Container security
* Understanding container security
* Understanding host and VM security
* Hardening Red Hat Enterprise Linux CoreOS
* Container image signatures
* Understanding compliance
* Securing container content
* Using container registries securely
* Securing the build process
* Deploying containers
* Securing the container platform
* Securing networks
* Securing attached storage
* Monitoring cluster events and logs
* Configuring certificates
* Replacing the default ingress certificate
* Adding API server certificates
* Securing service traffic using service serving certificates
* Certificate types and descriptions
* User-provided certificates for the API server
* Proxy certificates
* Service CA certificates
* Node certificates
* Bootstrap certificates
* etcd certificates
* OLM certificates
* User-provided certificates for default ingress
* Ingress certificates
* Monitoring and cluster logging Operator component certificates
* Control plane certificates
* Viewing audit logs
* Allowing JavaScript-based access to the API server from additional hosts
* Encrypting etcd data
* Scanning pods for vulnerabilities
* Authentication and authorization
* Understanding authentication
* Configuring the internal OAuth server
* Understanding identity provider configuration
* Configuring identity providers
* Configuring an HTPasswd identity provider
* Configuring a Keystone identity provider
* Configuring an LDAP identity provider
* Configuring a basic authentication identity provider
* Configuring a request header identity provider
* Configuring a GitHub or GitHub Enterprise identity provider
* Configuring a GitLab identity provider
* Configuring a Google identity provider
* Configuring an OpenID Connect identity provider
* Using RBAC to define and apply permissions
* Removing the kubeadmin user
* Understanding and creating service accounts
* Using service accounts in applications
* Using a service account as an OAuth client
* Scoping tokens
* Using bound service account tokens
* Managing security context constraints
* Impersonating the system:admin user
* Syncing LDAP groups
* Creating and using config maps
* Networking
* Understanding networking
* Accessing hosts
* Understanding the Cluster Network Operator
* Understanding the DNS Operator
* Understanding the Ingress Operator
* Using SCTP
* Configuring PTP hardware
* Network policy
* About network policy
* Creating a network policy
* Viewing a network policy
* Editing a network policy
* Deleting a network policy
* Defining a default network policy for projects
* Configuring multitenant network policy
* Multiple networks
* Understanding multiple networks
* Attaching a Pod to an additional network
* Removing a Pod from an additional network
* Configuring a bridge network
* Configuring a host-device network
* Configuring an ipvlan network
* Configuring a macvlan network with basic customizations
* Configuring a macvlan network
* Editing an additional network
* Removing an additional network
* Hardware networks
* About Single Root I/O Virtualization (SR-IOV) hardware networks
* Installing the SR-IOV Operator
* Configuring the SR-IOV Operator
* Configuring an SR-IOV network device
* Configuring an SR-IOV Ethernet network attachment
* Adding Pod to an SR-IOV network
* Using high performance multicast
* Using DPDK and RDMA
* OpenShift SDN default CNI network provider
* About the OpenShift SDN default CNI network provider
* Configuring egress IPs for a project
* Configuring an egress firewall for a project
* Editing an egress firewall for a project
* Removing an egress firewall from a project
* Considerations for the use of an egress router pod
* Deploying an egress router pod in redirect mode
* Deploying an egress router pod in HTTP proxy mode
* Deploying an egress router pod in DNS proxy mode
* Configuring an egress router pod destination list from a config map
* Enabling multicast for a project
* Disabling multicast for a project
* Configuring multitenant isolation
* Configuring kube-proxy
* OVN-Kubernetes default CNI network provider
* About the OVN-Kubernetes network provider
* Migrate from the OpenShift SDN default CNI network provider
* Rollback to the OpenShift SDN default CNI network provider
* Enabling multicast for a project
* Disabling multicast for a project
* Configuring Routes
* Route configuration
* Secured routes
* Configuring ingress cluster traffic
* Overview
* Configuring ExternalIPs for services
* Configuring ingress cluster traffic using an Ingress Controller
* Configuring ingress cluster traffic using a load balancer
* Configuring ingress cluster traffic using a service external IP
* Configuring ingress cluster traffic using a NodePort
* Configuring the cluster-wide proxy
* Configuring a custom PKI
* Load balancing on OpenStack
* Storage
* Understanding ephemeral storage
* Understanding persistent storage
* Configuring persistent storage
* Persistent storage using AWS Elastic Block Store
* Persistent storage using Azure Disk
* Persistent storage using Azure File
* Persistent storage using Cinder
* Persistent storage using Fibre Channel
* Persistent storage using FlexVolume
* Persistent storage using GCE Persistent Disk
* Persistent storage using hostPath
* Persistent Storage using iSCSI
* Persistent storage using local volumes
* Persistent storage using NFS
* Persistent storage using Red Hat OpenShift Container Storage
* Persistent storage using VMware vSphere
* Using Container Storage Interface (CSI)
* Configuring CSI volumes
* CSI inline ephemeral volumes
* CSI volume snapshots
* CSI volume cloning
* AWS Elastic Block Store CSI Driver Operator
* OpenStack Manila CSI Driver Operator
* Expanding persistent volumes
* Dynamic provisioning
* Registry
* Overview
* Image Registry Operator in OpenShift Container Platform
* Setting up and configuring the registry
* Configuring the registry for AWS user-provisioned infrastructure
* Configuring the registry for GCP user-provisioned infrastructure
* Configuring the registry for Azure user-provisioned infrastructure
* Configuring the registry for bare metal
* Configuring the registry for vSphere
* Registry options
* Accessing the registry
* Exposing the registry
* Operators
* Understanding Operators
* What are Operators?
* Common terms
* Packaging formats
* Operator Lifecycle Manager (OLM)
* Concepts
* Architecture
* Workflow
* Dependency resolution
* Operator groups
* Metrics
* OperatorHub
* CRDs
* Extending the Kubernetes API with CRDs
* Managing resources from CRDs
* User tasks
* Creating applications from installed Operators
* Installing Operators in your namespace
* Managing admission webhooks in OLM
* Administrator tasks
* Adding Operators to a cluster
* Upgrading installed Operators
* Deleting Operators from a cluster
* Configuring proxy support
* Viewing Operator status
* Allowing non-cluster administrators to install Operators
* Managing custom catalogs
* Using OLM on restricted networks
* Developing Operators
* Getting started with the Operator SDK
* Creating Ansible-based Operators
* Creating Helm-based Operators
* Generating a cluster service version (CSV)
* Working with bundle images
* Validating Operators using the scorecard
* Configuring built-in monitoring with Prometheus
* Configuring leader election
* Operator SDK CLI reference
* Appendices
* Red Hat Operators reference
* Builds
* Understanding image builds
* Understanding build configurations
* Creating build inputs
* Managing build output
* Using build strategies
* Custom image builds with Buildah
* Performing basic builds
* Triggering and modifying builds
* Performing advanced builds
* Using Red Hat subscriptions in builds
* Securing builds by strategy
* Build configuration resources
* Troubleshooting builds
* Setting up additional trusted certificate authorities for builds
* Pipelines
* Understanding OpenShift Pipelines
* Installing OpenShift Pipelines
* Uninstalling OpenShift Pipelines
* Creating CI/CD solutions for applications using OpenShift Pipelines
* Working with Pipelines using the Developer perspective
* OpenShift Pipelines release notes
* Images
* Configuring the Cluster Samples Operator
* Using the Cluster Samples Operator with an alternate registry
* Understanding containers, images, and imagestreams
* Creating images
* Managing images
* Managing images overview
* Tagging images
* Image pull policy
* Using image pull secrets
* Managing image streams
* Using image streams with Kubernetes resources
* Triggering updates on image stream changes
* Image configuration resources
* Using templates
* Using Ruby on Rails
* Using images
* Using images overview
* Configuring Jenkins images
* Jenkins agent
* Source-to-image
* Customizing source-to-image images
* Applications
* Projects
* Working with projects
* Creating a project as another user
* Configuring project creation
* Application life cycle management
* Creating applications using the Developer perspective
* Creating applications from installed Operators
* Creating applications using the CLI
* Viewing application composition using the Topology view
* Editing applications
* Working with Helm charts using the Developer perspective
* Deleting applications
* Deployments
* Understanding Deployments and DeploymentConfigs
* Managing deployment processes
* Using deployment strategies
* Using route-based deployment strategies
* Quotas
* Resource quotas per project
* Resource quotas across multiple projects
* Monitoring project and application metrics using the Developer perspective
* Monitoring application health
* Idling applications
* Pruning objects to reclaim resources
* Using the Red Hat Marketplace
* Machine management
* Creating machine sets
* Creating a machine set on AWS
* Creating a machine set on Azure
* Creating a machine set on GCP
* Creating a machine set on OpenStack
* Creating a machine set on RHV
* Creating a machine set on vSphere
* Manually scaling a machine set
* Modifying a machine set
* Deleting a machine
* Applying autoscaling to a cluster
* Creating infrastructure machine sets
* Adding a RHEL compute machine
* Adding more RHEL compute machines
* User-provisioned infrastructure
* Adding compute machines to AWS using CloudFormation templates
* Adding compute machines to vSphere
* Adding compute machines to bare metal
* Deploying machine health checks
* Nodes
* Working with pods
* About Pods
* Viewing Pods
* Configuring a cluster for Pods
* Automatically scaling pods with the horizontal pod autoscaler
* Automatically adjust pod resource levels with the vertical pod autoscaler
* Providing sensitive data to Pods
* Using Device Manager to make devices available to nodes
* Including pod priority in Pod scheduling decisions
* Placing pods on specific nodes using node selectors
* Controlling pod placement onto nodes (scheduling)
* About pod placement using the scheduler
* Configuring the default scheduler to control pod placement
* Placing pods relative to other pods using pod affinity and anti-affinity
rules
* Controlling pod placement on nodes using node affinity rules
* Placing pods onto overcommited nodes
* Controlling pod placement using node taints
* Placing pods on specific nodes using node selectors
* Running a custom scheduler
* Evicting pods using the descheduler
* Using Jobs and DaemonSets
* Running background tasks on nodes automatically with daemonsets
* Running tasks in pods using jobs
* Working with nodes
* Viewing and listing the nodes in your cluster
* Working with nodes
* Managing Nodes
* Managing the maximum number of Pods per Node
* Using the Node Tuning Operator
* Understanding node rebooting
* Freeing node resources using garbage collection
* Allocating resources for nodes
* Allocating specific CPUs for nodes in a cluster
* Machine Config Daemon metrics
* Working with containers
* Using containers
* Using Init Containers to perform tasks before a pod is deployed
* Using volumes to persist container data
* Mapping volumes using projected volumes
* Allowing containers to consume API objects
* Copying files to or from a container
* Executing remote commands in a container
* Using port forwarding to access applications in a container
* Using sysctls in containers
* Working with clusters
* Viewing system event information in a cluster
* Analyzing cluster resource levels
* Setting limit ranges
* Configuring cluster memory to meet container memory and risk requirements
* Configuring your cluster to place pods on overcommited nodes
* Enabling features using FeatureGates
* Logging
* About cluster logging
* Installing cluster logging
* Configuring your cluster logging deployment
* About the Cluster Logging Custom Resource
* Configuring the logging collector
* Configuring the log store
* Configuring the log visualizer
* Configuring cluster logging storage
* Configuring CPU and memory limits for cluster logging components
* Using tolerations to control cluster logging pod placement
* Moving the cluster logging resources with node selectors
* Configuring systemd-journald for cluster logging
* Configuring the log curator
* Maintenance and support
* Viewing logs for a specific resource
* Viewing cluster logs in Kibana
* Forwarding logs to third party systems
* Collecting and storing Kubernetes events
* Updating cluster logging
* Troubleshooting cluster logging
* Viewing cluster logging status
* Viewing the status of the log store
* Understanding cluster logging alerts
* Troubleshooting the log curator
* Collecting logging data for Red Hat Support
* Uninstalling cluster logging
* Exported fields
* Monitoring
* Cluster monitoring
* About cluster monitoring
* Configuring the monitoring stack
* Managing cluster alerts
* Examining cluster metrics
* Accessing Prometheus, Alertmanager, and Grafana
* Monitoring your own services
* Exposing custom application metrics for autoscaling
* Metering
* About metering
* Installing metering
* Upgrading metering
* Configuring metering
* About configuring metering
* Common configuration options
* Configuring persistent storage
* Configuring the Hive metastore
* Configuring the reporting operator
* Configuring AWS billing correlation
* Reports
* About reports
* Storage Locations
* Using metering
* Examples of using metering
* Troubleshooting and debugging
* Uninstalling metering
* Scalability and performance
* Recommended installation practices
* Recommended host practices
* Recommended cluster scaling practices
* Using the Node Tuning Operator
* Using Cluster Loader
* Using CPU Manager
* Using Topology Manager
* Scaling the Cluster Monitoring Operator
* Planning your environment according to object maximums
* Optimizing storage
* Optimizing routing
* Optimizing networking
* What huge pages do and how they are consumed by apps
* Backup and restore
* Backing up etcd data
* Replacing an unhealthy etcd member
* Shutting down a cluster gracefully
* Restarting a cluster gracefully
* Disaster recovery
* About disaster recovery
* Recovering from lost master hosts
* Restoring to a previous cluster state
* Recovering from expired control plane certificates
* Migrating from OpenShift Container Platform 3 to 4
* About migrating from OpenShift Container Platform 3 to 4
* Differences between OpenShift Container Platform 3 and 4
* About MTC
* Installing MTC
* Installing MTC in a restricted network environment
* Upgrading MTC
* Premigration checklists
* Migrating your applications
* Advanced migration options
* Troubleshooting
* Migration Toolkit for Containers
* About MTC
* Installing MTC
* Installing MTC in a restricted network environment
* Upgrading MTC
* Premigration checklists
* Migrating your applications
* Advanced migration options
* Troubleshooting
* CLI tools
* OpenShift CLI (oc)
* Getting started with the CLI
* Configuring the CLI
* Extending the CLI with plug-ins
* Developer CLI commands
* Administrator CLI commands
* Usage of oc and kubectl commands
* Developer CLI (odo)
* Understanding odo
* odo architecture
* Installing odo
* Using odo in a restricted environment
* About odo in a restricted environment
* Pushing the odo init image to the restricted cluster registry
* Creating and deploying a component to the disconnected cluster
* Creating a single-component application with odo
* Creating a multicomponent application with odo
* Creating an application with a database
* Using devfiles in odo
* Using sample applications
* Creating instances of services managed by Operators
* Debugging applications in odo
* Managing environment variables in odo
* Configuring the odo CLI
* odo CLI reference
* odo release notes
* Helm CLI
* Getting started with Helm on OpenShift Container Platform
* Knative CLI (kn) for use with OpenShift Serverless
* Pipelines CLI (tkn)
* Installing tkn
* Configuring tkn
* Basic tkn commands
* API reference
* API list
* Common object reference
* Index
* Authorization APIs
* About Authorization APIs
* LocalResourceAccessReview [authorization.openshift.io/v1]
* LocalSubjectAccessReview [authorization.openshift.io/v1]
* ResourceAccessReview [authorization.openshift.io/v1]
* SelfSubjectRulesReview [authorization.openshift.io/v1]
* SubjectAccessReview [authorization.openshift.io/v1]
* SubjectRulesReview [authorization.openshift.io/v1]
* TokenReview [authentication.k8s.io/v1]
* LocalSubjectAccessReview [authorization.k8s.io/v1]
* SelfSubjectAccessReview [authorization.k8s.io/v1]
* SelfSubjectRulesReview [authorization.k8s.io/v1]
* SubjectAccessReview [authorization.k8s.io/v1]
* Autoscale APIs
* About Autoscale APIs
* ClusterAutoscaler [autoscaling.openshift.io/v1]
* MachineAutoscaler [autoscaling.openshift.io/v1beta1]
* HorizontalPodAutoscaler [autoscaling/v1]
* Config APIs
* About Config APIs
* APIServer [config.openshift.io/v1]
* Authentication [config.openshift.io/v1]
* Build [config.openshift.io/v1]
* ClusterOperator [config.openshift.io/v1]
* ClusterVersion [config.openshift.io/v1]
* Console [config.openshift.io/v1]
* DNS [config.openshift.io/v1]
* FeatureGate [config.openshift.io/v1]
* Image [config.openshift.io/v1]
* Infrastructure [config.openshift.io/v1]
* Ingress [config.openshift.io/v1]
* Network [config.openshift.io/v1]
* OAuth [config.openshift.io/v1]
* OperatorHub [config.openshift.io/v1]
* Project [config.openshift.io/v1]
* Proxy [config.openshift.io/v1]
* Scheduler [config.openshift.io/v1]
* Console APIs
* About Console APIs
* ConsoleCLIDownload [console.openshift.io/v1]
* ConsoleExternalLogLink [console.openshift.io/v1]
* ConsoleLink [console.openshift.io/v1]
* ConsoleNotification [console.openshift.io/v1]
* ConsoleYAMLSample [console.openshift.io/v1]
* Extension APIs
* About Extension APIs
* APIService [apiregistration.k8s.io/v1]
* CustomResourceDefinition [apiextensions.k8s.io/v1]
* MutatingWebhookConfiguration [admissionregistration.k8s.io/v1]
* ValidatingWebhookConfiguration [admissionregistration.k8s.io/v1]
* Image APIs
* About Image APIs
* Image [image.openshift.io/v1]
* ImageSignature [image.openshift.io/v1]
* ImageStreamImage [image.openshift.io/v1]
* ImageStreamImport [image.openshift.io/v1]
* ImageStreamMapping [image.openshift.io/v1]
* ImageStream [image.openshift.io/v1]
* ImageStreamTag [image.openshift.io/v1]
* ImageTag [image.openshift.io/v1]
* Machine APIs
* About Machine APIs
* ContainerRuntimeConfig [machineconfiguration.openshift.io/v1]
* ControllerConfig [machineconfiguration.openshift.io/v1]
* KubeletConfig [machineconfiguration.openshift.io/v1]
* MachineConfigPool [machineconfiguration.openshift.io/v1]
* MachineConfig [machineconfiguration.openshift.io/v1]
* MachineHealthCheck [machine.openshift.io/v1beta1]
* Machine [machine.openshift.io/v1beta1]
* MachineSet [machine.openshift.io/v1beta1]
* Metadata APIs
* About Metadata APIs
* Binding [core/v1]
* ComponentStatus [core/v1]
* ConfigMap [core/v1]
* ControllerRevision [apps/v1]
* Event [events.k8s.io/v1beta1]
* Event [core/v1]
* Lease [coordination.k8s.io/v1]
* Namespace [core/v1]
* Monitoring APIs
* About Monitoring APIs
* Alertmanager [monitoring.coreos.com/v1]
* PodMonitor [monitoring.coreos.com/v1]
* Prometheus [monitoring.coreos.com/v1]
* PrometheusRule [monitoring.coreos.com/v1]
* ServiceMonitor [monitoring.coreos.com/v1]
* ThanosRuler [monitoring.coreos.com/v1]
* Network APIs
* About Network APIs
* ClusterNetwork [network.openshift.io/v1]
* Endpoints [core/v1]
* EndpointSlice [discovery.k8s.io/v1beta1]
* EgressNetworkPolicy [network.openshift.io/v1]
* HostSubnet [network.openshift.io/v1]
* Ingress [networking.k8s.io/v1beta1]
* IngressClass [networking.k8s.io/v1beta1]
* NetNamespace [network.openshift.io/v1]
* NetworkAttachmentDefinition [k8s.cni.cncf.io/v1]
* NetworkPolicy [networking.k8s.io/v1]
* Route [route.openshift.io/v1]
* Service [core/v1]
* Node APIs
* About Node APIs
* Node [core/v1]
* Profile [tuned.openshift.io/v1]
* RuntimeClass [node.k8s.io/v1beta1]
* Tuned [tuned.openshift.io/v1]
* OAuth APIs
* About OAuth APIs
* OAuthAccessToken [oauth.openshift.io/v1]
* OAuthAuthorizeToken [oauth.openshift.io/v1]
* OAuthClientAuthorization [oauth.openshift.io/v1]
* OAuthClient [oauth.openshift.io/v1]
* Operator APIs
* About Operator APIs
* Authentication [operator.openshift.io/v1]
* Console [operator.openshift.io/v1]
* Config [operator.openshift.io/v1]
* Config [imageregistry.operator.openshift.io/v1]
* Config [samples.operator.openshift.io/v1]
* CSISnapshotController [operator.openshift.io/v1]
* DNS [operator.openshift.io/v1]
* DNSRecord [ingress.operator.openshift.io/v1]
* Etcd [operator.openshift.io/v1]
* ImageContentSourcePolicy [operator.openshift.io/v1alpha1]
* ImagePruner [imageregistry.operator.openshift.io/v1]
* IngressController [operator.openshift.io/v1]
* KubeAPIServer [operator.openshift.io/v1]
* KubeControllerManager [operator.openshift.io/v1]
* KubeScheduler [operator.openshift.io/v1]
* KubeStorageVersionMigrator [operator.openshift.io/v1]
* Network [operator.openshift.io/v1]
* OpenShiftAPIServer [operator.openshift.io/v1]
* OpenShiftControllerManager [operator.openshift.io/v1]
* ServiceCA [operator.openshift.io/v1]
* OperatorHub APIs
* About OperatorHub APIs
* CatalogSource [operators.coreos.com/v1alpha1]
* ClusterServiceVersion [operators.coreos.com/v1alpha1]
* InstallPlan [operators.coreos.com/v1alpha1]
* OperatorGroup [operators.coreos.com/v1]
* OperatorSource [operators.coreos.com/v1]
* PackageManifest [packages.operators.coreos.com/v1]
* Subscription [operators.coreos.com/v1alpha1]
* Policy APIs
* About Policy APIs
* PodDisruptionBudget [policy/v1beta1]
* Project APIs
* About Project APIs
* Project [project.openshift.io/v1]
* ProjectRequest [project.openshift.io/v1]
* RBAC APIs
* About RBAC APIs
* ClusterRoleBinding [rbac.authorization.k8s.io/v1]
* ClusterRole [rbac.authorization.k8s.io/v1]
* RoleBinding [rbac.authorization.k8s.io/v1]
* Role [rbac.authorization.k8s.io/v1]
* Role APIs
* About Role APIs
* ClusterRoleBinding [authorization.openshift.io/v1]
* ClusterRole [authorization.openshift.io/v1]
* RoleBindingRestriction [authorization.openshift.io/v1]
* RoleBinding [authorization.openshift.io/v1]
* Role [authorization.openshift.io/v1]
* Schedule and quota APIs
* About Schedule and quota APIs
* AppliedClusterResourceQuota [quota.openshift.io/v1]
* ClusterResourceQuota [quota.openshift.io/v1]
* LimitRange [core/v1]
* PriorityClass [scheduling.k8s.io/v1]
* ResourceQuota [core/v1]
* Security APIs
* About Security APIs
* CertificateSigningRequest [certificates.k8s.io/v1beta1]
* CredentialsRequest [cloudcredential.openshift.io/v1]
* PodSecurityPolicyReview [security.openshift.io/v1]
* PodSecurityPolicySelfSubjectReview [security.openshift.io/v1]
* PodSecurityPolicySubjectReview [security.openshift.io/v1]
* RangeAllocation [security.openshift.io/v1]
* Secret [core/v1]
* SecurityContextConstraints [security.openshift.io/v1]
* ServiceAccount [core/v1]
* Storage APIs
* About Storage APIs
* CSIDriver [storage.k8s.io/v1]
* CSINode [storage.k8s.io/v1]
* PersistentVolumeClaim [core/v1]
* StorageClass [storage.k8s.io/v1]
* VolumeAttachment [storage.k8s.io/v1]
* VolumeSnapshot [snapshot.storage.k8s.io/v1beta1]
* VolumeSnapshotClass [snapshot.storage.k8s.io/v1beta1]
* VolumeSnapshotContent [snapshot.storage.k8s.io/v1beta1]
* Template APIs
* About Template APIs
* BrokerTemplateInstance [template.openshift.io/v1]
* PodTemplate [core/v1]
* Template [template.openshift.io/v1]
* TemplateInstance [template.openshift.io/v1]
* User and group APIs
* About User and group APIs
* Group [user.openshift.io/v1]
* Identity [user.openshift.io/v1]
* UserIdentityMapping [user.openshift.io/v1]
* User [user.openshift.io/v1]
* Workloads APIs
* About Workloads APIs
* BuildConfig [build.openshift.io/v1]
* Build [build.openshift.io/v1]
* CronJob [batch/v1beta1]
* DaemonSet [apps/v1]
* Deployment [apps/v1]
* DeploymentConfig [apps.openshift.io/v1]
* Job [batch/v1]
* Pod [core/v1]
* ReplicationController [core/v1]
* PersistentVolume [core/v1]
* ReplicaSet [apps/v1]
* StatefulSet [apps/v1]
* Service Mesh
* Service Mesh 1.x
* Service Mesh 1.x release notes
* Service Mesh architecture
* Service Mesh and Istio differences
* Preparing to install Service Mesh
* Installing Service Mesh
* Customizing the installation
* Deploying applications on Service Mesh
* Data visualization and observability
* Security
* Traffic management
* Using the 3scale Istio adapter
* Removing Service Mesh
* Jaeger
* Jaeger release notes
* Jaeger architecture
* Jaeger architecture
* Jaeger installation
* Installing Jaeger
* Configuring Jaeger
* Upgrading Jaeger
* Removing Jaeger
* OpenShift Virtualization
* About OpenShift Virtualization
* OpenShift Virtualization release notes
* OpenShift Virtualization installation
* Preparing your OpenShift cluster for OpenShift Virtualization
* Installing OpenShift Virtualization using the web console
* Installing OpenShift Virtualization using the CLI
* Installing the virtctl client
* Uninstalling OpenShift Virtualization using the web console
* Uninstalling OpenShift Virtualization using the CLI
* Upgrading OpenShift Virtualization
* Additional security privileges granted for kubevirt-controller and
virt-launcher
* Using the CLI tools
* Virtual machines
* Creating virtual machines
* Editing virtual machines
* Editing boot order
* Deleting virtual machines
* Managing virtual machine instances
* Controlling virtual machines states
* Accessing virtual machine consoles
* Managing ConfigMaps, secrets, and service accounts in virtual machines
* Installing VirtIO driver on an existing Windows virtual machine
* Installing VirtIO driver on a new Windows virtual machine
* Advanced virtual machine management
* Automating management tasks
* Configuring PXE booting for virtual machines
* Managing guest memory
* Using huge pages with virtual machines
* Enabling dedicated resources for a virtual machine
* Importing virtual machines
* TLS certificates for DataVolume imports
* Importing virtual machine images with DataVolumes
* Importing virtual machine images to block storage with DataVolumes
* Importing a Red Hat Virtualization virtual machine
* Importing a VMware virtual machine or template
* Cloning virtual machines
* Enabling user permissions to clone DataVolumes across namespaces
* Cloning a virtual machine disk into a new DataVolume
* Cloning a virtual machine by using a DataVolumeTemplate
* Cloning a virtual machine disk into a new block storage DataVolume
* Virtual machine networking
* Using the default Pod network with OpenShift Virtualization
* Attaching a virtual machine to multiple networks
* Configuring an SR-IOV network device for virtual machines
* Defining an SR-IOV network
* Attaching a virtual machine to an SR-IOV network
* Installing the QEMU guest agent on virtual machines
* Viewing the IP address of NICs on a virtual machine
* Using a MAC address pool for virtual machines
* Virtual machine disks
* Features for storage
* Configuring local storage for virtual machines
* Configuring CDI to work with namespaces that have a compute resource
quota
* Uploading local disk images by using the virtctl tool
* Uploading a local disk image to a block storage DataVolume
* Moving a local virtual machine disk to a different node
* Expanding virtual storage by adding blank disk images
* Storage defaults for DataVolumes
* Using container disks with virtual machines
* Preparing CDI scratch space
* Re-using statically provisioned persistent volumes
* Deleting DataVolumes
* Virtual machine templates
* Creating virtual machine templates
* Editing a virtual machine template
* Enabling dedicated resources for a virtual machine template
* Deleting a virtual machine template
* Live migration
* Virtual machine live migration
* Live migration limits and timeouts
* Migrating a virtual machine instance to another node
* Monitoring live migration of a virtual machine instance
* Cancelling the live migration of a virtual machine instance
* Configuring virtual machine eviction strategy
* Node maintenance
* Automatic renewal of TLS certificates
* Node maintenance mode
* Setting a node to maintenance mode
* Resuming a node from maintenance mode
* Node networking
* Observing node network state
* Updating node network configuration
* Troubleshooting node network configuration
* Logging, events, and monitoring
* Viewing logs
* Viewing events
* Diagnosing DataVolumes using events and conditions
* Viewing information about virtual machine workloads
* Monitoring virtual machine health
* Viewing cluster information
* OpenShift cluster monitoring, logging, and Telemetry
* Collecting OpenShift Virtualization data for Red Hat Support
* Serverless
* Release Notes
* Support
* Getting started
* Installing OpenShift Serverless
* Installing OpenShift Serverless
* Installing Knative Serving
* Installing Knative Eventing
* Advanced installation configuration options
* Upgrading the OpenShift Serverless Operator
* Removing OpenShift Serverless
* Installing the Knative CLI
* Architecture
* Knative Serving
* Knative Eventing
* Creating and managing serverless applications
* High availability on OpenShift Serverless
* Tracing requests
* Knative Serving
* Using kn to complete Serving tasks
* Configuring Knative Serving autoscaling
* Cluster logging with OpenShift Serverless
* Splitting traffic between revisions
* Event workflows
* Event delivery workflows using brokers and triggers
* Event delivery workflows using channels
* Event sources
* Getting started with event sources
* Using the kn CLI to list event sources and event source types
* Using an API server source
* Using a ping source
* Using sink binding
* Networking
* Using Service Mesh with OpenShift Serverless
* Using JSON Web Token authentication with Service Mesh and OpenShift
Serverless
* Using custom domains for Knative services with Service Mesh
* Using metering with OpenShift Serverless
* Integrations
* Using NVIDIA GPU resources with serverless applications
×
Show more results
OPENSHIFT CONTAINER PLATFORM 4.5 DOCUMENTATION
Welcome to the official OpenShift Container Platform 4.5 documentation, where
you can find information to help you learn about OpenShift Container Platform
and start exploring its features.
To navigate the OpenShift Container Platform 4.5 documentation, you can either
* Use the left navigation bar to browse the documentation or
* Select the activity that interests you from the contents of this Welcome page
You can start with Architecture and Security. Then see Release Notes.
CLUSTER INSTALLER ACTIVITIES
As someone setting out to install an OpenShift Container Platform 4.5 cluster,
this documentation will help you:
* Install a cluster on AWS: You have the most installation options when you
deploy a cluster on Amazon Web Services (AWS). You can deploy clusters with
default settings or custom AWS settings. You can also deploy a cluster on AWS
infrastructure that you provisioned yourself. You can modify the provided AWS
CloudFormation templates to meet your needs.
* Install a cluster on Azure: You can deploy clusters with default settings,
custom Azure settings, or custom networking settings in Microsoft Azure. You
can also provision OpenShift Container Platform into an Azure Virtual Network
or use Azure Resource Manager Templates to provision your own infrastructure.
* Install a cluster on GCP: You can deploy clusters with default settings or
custom GCP settings on Google Cloud Platform (GCP). You can also perform a
GCP installation where you provision your own infrastructure.
* Install a cluster on VMware vSphere: You can install OpenShift Container
Platform on supported versions of vSphere.
* Install a cluster on bare metal: If none of the available platform and cloud
providers meet your needs, you can install OpenShift Container Platform on
bare metal.
* Install a cluster on Red Hat OpenStack Platform (RHOSP): You can install a
cluster on RHOSP with customizations.
* Install a cluster on Red Hat Virtualization (RHV): You can deploy clusters on
Red Hat Virtualization (RHV) with a quick install or an install with
customizations.
* Install a cluster in a restricted network: If your cluster that uses
user-provisioned infrastructure on AWS, GCP, vSphere, or bare metal does not
have full access to the internet, you can mirror the OpenShift Container
Platform installation images and install a cluster in a restricted network.
* Install a cluster in an existing network: If you use an existing Virtual
Private Cloud (VPC) in AWS or GCP or an existing VNet on Azure, you can
install a cluster.
* Install a private cluster: If your cluster does not require external internet
access, you can install a private cluster on AWS, Azure, or GCP. Internet
access is still required to access the cloud APIs and installation media.
* Check installation logs: Access installation logs to evaluate issues that
occur during OpenShift Container Platform 4.5 installation.
* Access OpenShift Container Platform: Use credentials output at the end of the
installation process to log in to the OpenShift Container Platform cluster
from the command line or web console.
* Install Red Hat OpenShift Container Storage
DEVELOPER ACTIVITIES
Ultimately, OpenShift Container Platform is a platform for developing and
deploying containerized applications. As an application developer, OpenShift
Container Platform documentation will help you:
* Understand OpenShift Container Platform development: Learn the different
types of containerized applications, from simple containers to advanced
Kubernetes deployments and Operators.
* Work with projects: Create projects from the web console or CLI to organize
and share the software you develop.
* Work with applications: Use the Developer perspective in the OpenShift
Container Platform web console to easily create and deploy applications. Use
the Topology view to visually interact with your applications, monitor
status, connect and group components, and modify your code base.
* Use the developer CLI tool (odo): The odo CLI tool lets developers create
single or multi-component applications easily and automates deployment,
build, and service route configurations. It abstracts complex Kubernetes and
OpenShift Container Platform concepts, allowing developers to focus on
developing their applications.
* Create CI/CD Pipelines: Pipelines are serverless, cloud-native, continuous
integration and continuous deployment systems that run in isolated
containers. They use standard Tekton custom resources to automate deployments
and are designed for decentralized teams that work on microservices-based
architecture.
* Deploy Helm charts: Helm 3 is a package manager that helps developers define,
install, and update application packages on Kubernetes. A Helm chart is a
packaging format that describes an application that can be deployed using the
Helm CLI.
* Understand Operators: Operators are the preferred method for creating
on-cluster applications for OpenShift Container Platform 4.5. Learn about the
Operator Framework and how to deploy applications using installed Operators
into your projects.
* Understand image builds: Choose from different build strategies (Docker, S2I,
custom, and pipeline) that can include different kinds of source materials
(from places like Git repositories, local binary inputs, and external
artifacts). Then, follow examples of build types from basic builds to
advanced builds.
* Create container images: A container image is the most basic building block
in OpenShift Container Platform (and Kubernetes) applications. Defining image
streams lets you gather multiple versions of an image in one place as you
continue its development. S2I containers let you insert your source code into
a base container that is set up to run code of a particular type (such as
Ruby, Node.js, or Python).
* Create deployments: Use Deployment and DeploymentConfig objects to exert
fine-grained management over applications. Use the Workloads page or oc CLI
to manage deployments. Learn rolling, recreate, and custom deployment
strategies.
* Create templates: Use existing templates or create your own templates that
describe how an application is built or deployed. A template can combine
images with descriptions, parameters, replicas, exposed ports and other
content that defines how an application can be run or built.
* Create Operators: Operators are the preferred method for creating on-cluster
applications for OpenShift Container Platform 4.5. Learn the workflow for
building, testing, and deploying Operators. Then create your own Operators
based on Ansible or Helm, or configure built-in Prometheus monitoring using
the Operator SDK.
* REST API reference: Lists OpenShift Container Platform application
programming interface endpoints.
CLUSTER ADMINISTRATOR ACTIVITIES
Ongoing tasks on your OpenShift Container Platform 4.5 cluster include various
activities for managing machines, providing services to users, and following
monitoring and logging features that watch over the cluster. As a cluster
administrator, this documentation will help you:
* Understand OpenShift Container Platform management: Learn about components of
the OpenShift Container Platform 4.5 control plane. See how OpenShift
Container Platform masters and workers are managed and updated through the
Machine API and Operators.
MANAGE CLUSTER COMPONENTS
* Manage machines: Manage machines in your cluster on AWS, Azure, or GCP by
deploying health checks and applying autoscaling to machines.
* Manage container registries: Each OpenShift Container Platform cluster
includes a built-in container registry for storing its images. You can also
configure a separate Red Hat Quay registry to use with OpenShift Container
Platform. The Quay.io web site provides a public container registry that
stores OpenShift Container Platform containers and Operators.
* Manage users and groups: Add users and groups that have different levels of
permissions to use or modify clusters.
* Manage authentication: Learn how user, group, and API authentication works in
OpenShift Container Platform. OpenShift Container Platform supports multiple
identity providers, including HTPasswd, Keystone, LDAP, basic authentication,
request header, GitHub, GitLab, Google, and OpenID.
* Manage ingress, API server, and service certificates: OpenShift Container
Platform creates certificates by default for the Ingress Operator, the API
server, and for services needed by complex middleware applications that
require encryption. At some point, you might need to change, add, or rotate
these certificates.
* Manage networking: Networking in OpenShift Container Platform is managed by
the Cluster Network Operator (CNO). The CNO uses iptables rules in kube-proxy
to direct traffic between nodes and pods running on those nodes. The Multus
Container Network Interface adds the capability to attach multiple network
interfaces to a pod. Using network policy features, you can isolate your pods
or permit selected traffic.
* Manage storage: OpenShift Container Platform allows cluster administrators to
configure persistent storage using Red Hat OpenShift Container Storage, AWS
Elastic Block Store, NFS, iSCSI, Container Storage Interface (CSI), and more.
As needed, you can expand persistent volumes, configure dynamic provisioning,
and use CSI to configure and clone persistent storage.
* Manage Operators: Lists of Red Hat, ISV, and community Operators can be
reviewed by cluster administrators and installed on their clusters. Once
installed, you can run, upgrade, back up or otherwise manage the Operator on
your cluster (based on what the Operator is designed to do).
CHANGE CLUSTER COMPONENTS
* Use custom resource definitions (CRDs) to modify the cluster: Cluster
features that are implemented with Operators, can be modified with CRDs.
Learn to create a CRD and manage resources from CRDs.
* Set resource quotas: Choose from CPU, memory and other system resources to
set quotas.
* Prune and reclaim resources: You can reclaim space by pruning unneeded
Operators, groups, deployments, builds, images, registries, and cron jobs.
* Scale and tune clusters: Set cluster limits, tune nodes, scale cluster
monitoring, and optimize networking, storage, and routes for your
environment.
* Update a cluster: To upgrade your OpenShift Container Platform to a later
version, use the Cluster Version Operator (CVO). If an update is available
from the Container Platform update service, you apply that cluster update
from either the web console or the CLI.
MONITOR THE CLUSTER
* Work with cluster logging: Learn about cluster logging and configure
different cluster logging types, such as Elasticsearch, Fluentd, Kibana, and
Curator.
* Monitor clusters: Learn to configure the monitoring. Once your monitoring is
configured, use the Web UI to access Prometheus, Alertmanager, and Grafana.
In addition to infrastructure metrics, you can also scrape and view metrics
for your own services.
* Remote health monitoring: OpenShift Container Platform collects anonymized
aggregated information about your cluster and reports it to Red Hat via
Telemetry and the Insights Operator. This information allows Red Hat to
improve OpenShift Container Platform and to react to issues that impact
customers more quickly. You can view the data collected by remote health
monitoring.
Copyright © 2022 Red Hat, Inc.
Privacy statement Terms of use All policies and guidelines Cookie-Präferenzen