Datasets:

mtpti5iD
/

redhat-docs_dataset

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 44.6k rows

Subsets and Splits

No saved queries yet

Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.

title stringlengths 4 168	content stringlengths 7 1.74M	commands sequencelengths 1 5.62k ⌀	url stringlengths 79 342
Chapter 24. Bottom-Up Service Development	Chapter 24. Bottom-Up Service Development Abstract There are many instances where you have Java code that already implements a set of functionality that you want to expose as part of a service oriented application. You may also simply want to avoid using WSDL to define your interface. Using JAX-WS annotations, you can add the information required to service enable a Java class. You can also create a Service Endpoint Interface (SEI) that can be used in place of a WSDL contract. If you want a WSDL contract, Apache CXF provides tools to generate a contract from annotated Java code. 24.1. Introduction to JAX-WS Service Development To create a service starting from Java you must do the following: Section 24.2, "Creating the SEI" a Service Endpoint Interface (SEI) that defines the methods you want to expose as a service. Note You can work directly from a Java class, but working from an interface is the recommended approach. Interfaces are better suited for sharing with the developers who are responsible for developing the applications consuming your service. The interface is smaller and does not provide any of the service's implementation details. Section 24.3, "Annotating the Code" the required annotations to your code. Section 24.4, "Generating WSDL" the WSDL contract for your service. Note If you intend to use the SEI as the service's contract, it is not necessary to generate a WSDL contract. Chapter 31, Publishing a Service the service as a service provider. 24.2. Creating the SEI Overview The service endpoint interface (SEI) is the piece of Java code that is shared between a service implementation and the consumers that make requests on that service. The SEI defines the methods implemented by the service and provides details about how the service will be exposed as an endpoint. When starting with a WSDL contract, the SEI is generated by the code generators. However, when starting from Java, it is the developer's responsibility to create the SEI. There are two basic patterns for creating an SEI: Green field development - In this pattern, you are developing a new service without any existing Java code or WSDL. It is best to start by creating the SEI. You can then distribute the SEI to any developers that are responsible for implementing the service providers and consumers that use the SEI. Note The recommended way to do green field service development is to start by creating a WSDL contract that defines the service and its interfaces. See Chapter 26, A Starting Point WSDL Contract . Service enablement - In this pattern, you typically have an existing set of functionality that is implemented as a Java class, and you want to service enable it. This means that you must do two things: Create an SEI that contains only the operations that are going to be exposed as part of the service. Modify the existing Java class so that it implements the SEI. Note Although you can add the JAX-WS annotations to a Java class, it is not recommended. Writing the interface The SEI is a standard Java interface. It defines a set of methods that a class implements. It can also define a number of member fields and constants to which the implementing class has access. In the case of an SEI the methods defined are intended to be mapped to operations exposed by a service. The SEI corresponds to a wsdl:portType element. The methods defined by the SEI correspond to wsdl:operation elements in the wsdl:portType element. Note JAX-WS defines an annotation that allows you to specify methods that are not exposed as part of a service. However, the best practice is to leave those methods out of the SEI. Example 24.1, "Simple SEI" shows a simple SEI for a stock updating service. Example 24.1. Simple SEI Implementing the interface Because the SEI is a standard Java interface, the class that implements it is a standard Java class. If you start with a Java class you must modify it to implement the interface. If you start with the SEI, the implementation class implements the SEI. Example 24.2, "Simple Implementation Class" shows a class for implementing the interface in Example 24.1, "Simple SEI" . Example 24.2. Simple Implementation Class 24.3. Annotating the Code 24.3.1. Overview of JAX-WS Annotations The JAX-WS annotations specify the metadata used to map the SEI to a fully specified service definition. Among the information provided in the annotations are the following: The target namespace for the service. The name of the class used to hold the request message The name of the class used to hold the response message If an operation is a one way operation The binding style the service uses The name of the class used for any custom exceptions The namespaces under which the types used by the service are defined Note Most of the annotations have sensible defaults and it is not necessary to provide values for them. However, the more information you provide in the annotations, the better your service definition is specified. A well-specified service definition increases the likelihood that all parts of a distributed application will work together. 24.3.2. Required Annotations Overview In order to create a service from Java code you are only required to add one annotation to your code. You must add the @WebService annotation on both the SEI and the implementation class. The @WebService annotation The @WebService annotation is defined by the javax.jws.WebService interface and it is placed on an interface or a class that is intended to be used as a service. @WebService has the properties described in Table 24.1, " @WebService Properties" Table 24.1. @WebService Properties Property Description name Specifies the name of the service interface. This property is mapped to the name attribute of the wsdl:portType element that defines the service's interface in a WSDL contract. The default is to append PortType to the name of the implementation class. [a] targetNamespace Specifies the target namespace where the service is defined. If this property is not specified, the target namespace is derived from the package name. serviceName Specifies the name of the published service. This property is mapped to the name attribute of the wsdl:service element that defines the published service. The default is to use the name of the service's implementation class. wsdlLocation Specifies the URL where the service's WSDL contract is stored. This must be specified using a relative URL. The default is the URL where the service is deployed. endpointInterface Specifies the full name of the SEI that the implementation class implements. This property is only specified when the attribute is used on a service implementation class. portName Specifies the name of the endpoint at which the service is published. This property is mapped to the name attribute of the wsdl:port element that specifies the endpoint details for a published service. The default is the append Port to the name of the service's implementation class. [a] When you generate WSDL from an SEI the interface's name is used in place of the implementation class' name. Note It is not necessary to provide values for any of the @WebService annotation's properties. However, we recommended that you provide as much information as you can. Annotating the SEI The SEI requires that you add the @WebService annotation. Because the SEI is the contract that defines the service, you should specify as much detail as possible about the service in the @WebService annotation's properties. Example 24.3, "Interface with the @WebService Annotation" shows the interface defined in Example 24.1, "Simple SEI" with the @WebService annotation. Example 24.3. Interface with the @WebService Annotation The @WebService annotation in Example 24.3, "Interface with the @WebService Annotation" does the following: Specifies that the value of the name attribute of the wsdl:portType element defining the service interface is quoteUpdater . Specifies that the target namespace of the service is http://demos.redhat.com . Specifies that the value of the name of the wsdl:service element defining the published service is updateQuoteService . Specifies that the service will publish its WSDL contract at http://demos.redhat.com/quoteExampleService?wsdl . Specifies that the value of the name attribute of the wsdl:port element defining the endpoint exposing the service is updateQuotePort . Annotating the service implementation In addition to annotating the SEI with the @WebService annotation, you also must annotate the service implementation class with the @WebService annotation. When adding the annotation to the service implementation class you only need to specify the endpointInterface property. As shown in Example 24.4, "Annotated Service Implementation Class" the property must be set to the full name of the SEI. Example 24.4. Annotated Service Implementation Class 24.3.3. Optional Annotations Abstract While the @WebService annotation is sufficient for service enabling a Java interface or a Java class, it does not fully describe how the service will be exposed as a service provider. The JAX-WS programming model uses a number of optional annotations for adding details about your service, such as the binding it uses, to the Java code. You add these annotations to the service's SEI. The more details you provide in the SEI the easier it is for developers to implement applications that can use the functionality it defines. It also makes the WSDL documents generated by the tools more specific. Overview Defining the Binding Properties with Annotations If you are using a SOAP binding for your service, you can use JAX-WS annotations to specify a number of the bindings properties. These properties correspond directly to the properties you can specify in a service's WSDL contract. Some of the settings, such as the parameter style, can restrict how you implement a method. These settings can also effect which annotations can be used when annotating method parameters. The @SOAPBinding annotation The @SOAPBinding annotation is defined by the javax.jws.soap.SOAPBinding interface. It provides details about the SOAP binding used by the service when it is deployed. If the @SOAPBinding annotation is not specified, a service is published using a wrapped doc/literal SOAP binding. You can put the @SOAPBinding annotation on the SEI and any of the SEI's methods. When it is used on a method, setting of the method's @SOAPBinding annotation take precedence. Table 24.2, " @SOAPBinding Properties" shows the properties for the @SOAPBinding annotation. Table 24.2. @SOAPBinding Properties Property Values Description style Style.DOCUMENT (default) Style.RPC Specifies the style of the SOAP message. If RPC style is specified, each message part within the SOAP body is a parameter or return value and appears inside a wrapper element within the soap:body element. The message parts within the wrapper element correspond to operation parameters and must appear in the same order as the parameters in the operation. If DOCUMENT style is specified, the contents of the SOAP body must be a valid XML document, but its form is not as tightly constrained. use Use.LITERAL (default) Use.ENCODED [a] Specifies how the data of the SOAP message is streamed. parameterStyle [b] ParameterStyle.BARE ParameterStyle.WRAPPED (default) Specifies how the method parameters, which correspond to message parts in a WSDL contract, are placed into the SOAP message body. If BARE is specified, each parameter is placed into the message body as a child element of the message root. If WRAPPED is specified, all of the input parameters are wrapped into a single element on a request message and all of the output parameters are wrapped into a single element in the response message. [a] Use.ENCODED is not currently supported. [b] If you set the style to RPC you must use the WRAPPED parameter style. Document bare style parameters Document bare style is the most direct mapping between Java code and the resulting XML representation of the service. When using this style, the schema types are generated directly from the input and output parameters defined in the operation's parameter list. You specify you want to use bare document\literal style by using the @SOAPBinding annotation with its style property set to Style.DOCUMENT, and its parameterStyle property set to ParameterStyle.BARE. To ensure that an operation does not violate the restrictions of using document style when using bare parameters, your operations must adhere to the following conditions: The operation must have no more than one input or input/output parameter. If the operation has a return type other than void , it must not have any output or input/output parameters. If the operation has a return type of void , it must have no more than one output or input/output parameter. Note Any parameters that are placed in the SOAP header using the @WebParam annotation or the @WebResult annotation are not counted against the number of allowed parameters. Document wrapped parameters Document wrapped style allows a more RPC like mapping between the Java code and the resulting XML representation of the service. When using this style, the parameters in the method's parameter list are wrapped into a single element by the binding. The disadvantage of this is that it introduces an extra-layer of indirection between the Java implementation and how the messages are placed on the wire. To specify that you want to use wrapped document\literal style use the @SOAPBinding annotation with its style property set to Style.DOCUMENT, and its parameterStyle property set to ParameterStyle.WRAPPED. You have some control over how the wrappers are generated by using the the section called "The @RequestWrapper annotation" annotation and the the section called "The @ResponseWrapper annotation" annotation. Example Example 24.5, "Specifying a Document Bare SOAP Binding with the SOAP Binding Annotation" shows an SEI that uses document bare SOAP messages. Example 24.5. Specifying a Document Bare SOAP Binding with the SOAP Binding Annotation Overview Defining Operation Properties with Annotations When the runtime maps your Java method definitions into XML operation definitions it provides details such as: What the exchanged messages look like in XML If the message can be optimized as a one way message The namespaces where the messages are defined The @WebMethod annotation The @WebMethod annotation is defined by the javax.jws.WebMethod interface. It is placed on the methods in the SEI. The @WebMethod annotation provides the information that is normally represented in the wsdl:operation element describing the operation to which the method is associated. Table 24.3, " @WebMethod Properties" describes the properties of the @WebMethod annotation. Table 24.3. @WebMethod Properties Property Description operationName Specifies the value of the associated wsdl:operation element's name . The default value is the name of the method. action Specifies the value of the soapAction attribute of the soap:operation element generated for the method. The default value is an empty string. exclude Specifies if the method should be excluded from the service interface. The default is false. The @RequestWrapper annotation The @RequestWrapper annotation is defined by the javax.xml.ws.RequestWrapper interface. It is placed on the methods in the SEI. The @RequestWrapper annotation specifies the Java class implementing the wrapper bean for the method parameters of the request message starting a message exchange. It also specifies the element names, and namespaces, used by the runtime when marshalling and unmarshalling the request messages. Table 24.4, " @RequestWrapper Properties" describes the properties of the @RequestWrapper annotation. Table 24.4. @RequestWrapper Properties Property Description localName Specifies the local name of the wrapper element in the XML representation of the request message. The default value is either the name of the method, or the value of the the section called "The @WebMethod annotation" annotation's operationName property. targetNamespace Specifies the namespace under which the XML wrapper element is defined. The default value is the target namespace of the SEI. className Specifies the full name of the Java class that implements the wrapper element. Note Only the className property is required. Important If the method is also annotated with the @SOAPBinding annotation, and its parameterStyle property is set to ParameterStyle.BARE , this annotation is ignored. The @ResponseWrapper annotation The @ResponseWrapper annotation is defined by the javax.xml.ws.ResponseWrapper interface. It is placed on the methods in the SEI. The @ResponseWrapper specifies the Java class implementing the wrapper bean for the method parameters in the response message in the message exchange. It also specifies the element names, and namespaces, used by the runtime when marshaling and unmarshalling the response messages. Table 24.5, " @ResponseWrapper Properties" describes the properties of the @ResponseWrapper annotation. Table 24.5. @ResponseWrapper Properties Property Description localName Specifies the local name of the wrapper element in the XML representation of the response message. The default value is either the name of the method with Response appended, or the value of the the section called "The @WebMethod annotation" annotation's operationName property with Response appended. targetNamespace Specifies the namespace where the XML wrapper element is defined. The default value is the target namespace of the SEI. className Specifies the full name of the Java class that implements the wrapper element. Note Only the className property is required. Important If the method is also annotated with the @SOAPBinding annotation and its parameterStyle property is set to ParameterStyle.BARE , this annotation is ignored. The @WebFault annotation The @WebFault annotation is defined by the javax.xml.ws.WebFault interface. It is placed on exceptions that are thrown by your SEI. The @WebFault annotation is used to map the Java exception to a wsdl:fault element. This information is used to marshall the exceptions into a representation that can be processed by both the service and its consumers. Table 24.6, " @WebFault Properties" describes the properties of the @WebFault annotation. Table 24.6. @WebFault Properties Property Description name Specifies the local name of the fault element. targetNamespace Specifies the namespace under which the fault element is defined. The default value is the target namespace of the SEI. faultName Specifies the full name of the Java class that implements the exception. Important The name property is required. The @Oneway annotation The @Oneway annotation is defined by the javax.jws.Oneway interface. It is placed on the methods in the SEI that will not require a response from the service. The @Oneway annotation tells the run time that it can optimize the execution of the method by not waiting for a response and by not reserving any resources to process a response. This annotation can only be used on methods that meet the following criteria: They return void They have no parameters that implement the Holder interface They do not throw any exceptions that can be passed back to a consumer Example Example 24.6, "SEI with Annotated Methods" shows an SEI with its methods annotated. Example 24.6. SEI with Annotated Methods Overview Defining Parameter Properties with Annotations The method parameters in the SEI correspond to the wsdl:message elements and their wsdl:part elements. JAX-WS provides annotations that allow you to describe the wsdl:part elements that are generated for the method parameters. The @WebParam annotation The @WebParam annotation is defined by the javax.jws.WebParam interface. It is placed on the parameters of the methods defined in the SEI. The @WebParam annotation allows you to specify the direction of the parameter, if the parameter will be placed in the SOAP header, and other properties of the generated wsdl:part . Table 24.7, " @WebParam Properties" describes the properties of the @WebParam annotation. Table 24.7. @WebParam Properties Property Values Description name Specifies the name of the parameter as it appears in the generated WSDL document. For RPC bindings, this is the name of the wsdl:part representing the parameter. For document bindings, this is the local name of the XML element representing the parameter. Per the JAX-WS specification, the default is arg N , where N is replaced with the zero-based argument index (i.e., arg0, arg1, etc.). targetNamespace Specifies the namespace for the parameter. It is only used with document bindings where the parameter maps to an XML element. The default is to use the service's namespace. mode Mode.IN (default) [a] Mode.OUT Mode.INOUT Specifies the direction of the parameter. header false (default) true Specifies if the parameter is passed as part of the SOAP header. partName Specifies the value of the name attribute of the wsdl:part element for the parameter. This property is used for document style SOAP bindings. [a] Any parameter that implements the Holder interface is mapped to Mode.INOUT by default. The @WebResult annotation The @WebResult annotation is defined by the javax.jws.WebResult interface. It is placed on the methods defined in the SEI. The @WebResult annotation allows you to specify the properties of the wsdl:part that is generated for the method's return value. Table 24.8, " @WebResult Properties" describes the properties of the @WebResult annotation. Table 24.8. @WebResult Properties Property Description name Specifies the name of the return value as it appears in the generated WSDL document. For RPC bindings, this is the name of the wsdl:part representing the return value. For document bindings, this is the local name of the XML element representing the return value. The default value is return. targetNamespace Specifies the namespace for the return value. It is only used with document bindings where the return value maps to an XML element. The default is to use the service's namespace. header Specifies if the return value is passed as part of the SOAP header. partName Specifies the value of the name attribute of the wsdl:part element for the return value. This property is used for document style SOAP bindings. Example Example 24.7, "Fully Annotated SEI" shows an SEI that is fully annotated. Example 24.7. Fully Annotated SEI 24.3.4. Apache CXF Annotations 24.3.4.1. WSDL Documentation @WSDLDocumentation annotation The @WSDLDocumentation annotation is defined by the org.apache.cxf.annotations.WSDLDocumentation interface. It can be placed on the SEI or the SEI methods. This annotation enables you to add documentation, which will then appear within wsdl:documentation elements after the SEI is converted to WSDL. By default, the documentation elements appear inside the port type, but you can specify the placement property to make the documentation appear at other locations in the WSDL file. Section 24.3.4.2, "@WSDLDocumentation properties" shows the properties supported by the @WSDLDocumentation annotation. 24.3.4.2. @WSDLDocumentation properties Property Description value (Required) A string containing the documentation text. placement (Optional) Specifies where in the WSDL file this documentation is to appear. For the list of possible placement values, see the section called "Placement in the WSDL contract" . faultClass (Optional) If the placement is set to be FAULT_MESSAGE , PORT_TYPE_OPERATION_FAULT , or BINDING_OPERATION_FAULT , you must also set this property to the Java class that represents the fault. @WSDLDocumentationCollection annotation The @WSDLDocumentationCollection annotation is defined by the org.apache.cxf.annotations.WSDLDocumentationCollection interface. It can be placed on the SEI or the SEI methods. This annotation is used to insert multiple documentation elements at a single placement location or at various placement locations. Placement in the WSDL contract To specify where the documentation should appear in the WSDL contract, you can specify the placement property, which is of type WSDLDocumentation.Placement . The placement can have one of the following values: WSDLDocumentation.Placement.BINDING WSDLDocumentation.Placement.BINDING_OPERATION WSDLDocumentation.Placement.BINDING_OPERATION_FAULT WSDLDocumentation.Placement.BINDING_OPERATION_INPUT WSDLDocumentation.Placement.BINDING_OPERATION_OUTPUT WSDLDocumentation.Placement.DEFAULT WSDLDocumentation.Placement.FAULT_MESSAGE WSDLDocumentation.Placement.INPUT_MESSAGE WSDLDocumentation.Placement.OUTPUT_MESSAGE WSDLDocumentation.Placement.PORT_TYPE WSDLDocumentation.Placement.PORT_TYPE_OPERATION WSDLDocumentation.Placement.PORT_TYPE_OPERATION_FAULT WSDLDocumentation.Placement.PORT_TYPE_OPERATION_INPUT WSDLDocumentation.Placement.PORT_TYPE_OPERATION_OUTPUT WSDLDocumentation.Placement.SERVICE WSDLDocumentation.Placement.SERVICE_PORT WSDLDocumentation.Placement.TOP Example of @WSDLDocumentation Section 24.3.4.3, "Using @WSDLDocumentation" shows how to add a @WSDLDocumentation annotation to the SEI and to one of its methods. 24.3.4.3. Using @WSDLDocumentation When WSDL, shown in Section 24.3.4.4, "WSDL generated with documentation" , is generated from the SEI in Section 24.3.4.3, "Using @WSDLDocumentation" , the default placements of the documentation elements are, respectively, PORT_TYPE and PORT_TYPE_OPERATION . 24.3.4.4. WSDL generated with documentation Example of @WSDLDocumentationCollection Section 24.3.4.5, "Using @WSDLDocumentationCollection" shows how to add a @WSDLDocumentationCollection annotation to an SEI. 24.3.4.5. Using @WSDLDocumentationCollection 24.3.4.6. Schema Validation of Messages @SchemaValidation annotation The @SchemaValidation annotation is defined by the org.apache.cxf.annotations.SchemaValidation interface. It can be placed on the SEI and on individual SEI methods. This annotation turns on schema validation of the XML messages sent to this endpoint. This can be useful for testing purposes, when you suspect there is a problem with the format of incoming XML messages. By default, validation is disabled, because it has a significant impact on performance. Schema validation type The schema validation behaviour is controlled by the type parameter, whose value is an enumeration of org.apache.cxf.annotations.SchemaValidation.SchemaValidationType type. Section 24.3.4.7, "Schema Validation Type Values" shows the list of available validation types. 24.3.4.7. Schema Validation Type Values Type Description IN Apply schema validation to incoming messages on client and server. OUT Apply schema validation to outgoing messages on client and server. BOTH Apply schema validation to both incoming and outgoing messages on client and server. NONE All schema validation is disabled. REQUEST Apply schema validation to Request messages-that is, causing validation to be applied to outgoing client messages and to incoming server messages. RESPONSE Apply schema validation to Response messages-that is, causing validation to be applied to incoming client messages, and outgoing server messages. Example The following example shows how to enable schema validation of messages for endpoints based on the MyService SEI. Note how the annotation can be applied to the SEI as a whole, as well as to individual methods in the SEI. 24.3.4.8. Specifying the Data Binding @DataBinding annotation The @DataBinding annotation is defined by the org.apache.cxf.annotations.DataBinding interface. It is placed on the SEI. This annotation is used to associate a data binding with the SEI, replacing the default JAXB data binding. The value of the @DataBinding annotation must be the class that provides the data binding, ClassName .class . Supported data bindings The following data bindings are currently supported by Apache CXF: org.apache.cxf.jaxb.JAXBDataBinding (Default) The standard JAXB data binding. org.apache.cxf.sdo.SDODataBinding The Service Data Objects (SDO) data binding is based on the Apache Tuscany SDO implementation. If you want to use this data binding in the context of a Maven build, you need to add a dependency on the cxf-rt-databinding-sdo artifact. org.apache.cxf.aegis.databinding.AegisDatabinding If you want to use this data binding in the context of a Maven build, you need to add a dependency on the cxf-rt-databinding-aegis artifact. org.apache.cxf.xmlbeans.XmlBeansDataBinding If you want to use this data binding in the context of a Maven build, you need to add a dependency on the cxf-rt-databinding-xmlbeans artifact. org.apache.cxf.databinding.source.SourceDataBinding This data binding belongs to the Apache CXF core. org.apache.cxf.databinding.stax.StaxDataBinding This data binding belongs to the Apache CXF core. Example Section 24.3.4.9, "Setting the data binding" shows how to associate the SDO binding with the HelloWorld SEI 24.3.4.9. Setting the data binding 24.3.4.10. Compressing Messages @GZIP annotation The @GZIP annotation is defined by the org.apache.cxf.annotations.GZIP interface. It is placed on the SEI. Enables GZIP compression of messages. GZIP is a negotiated enhancement. That is, an initial request from a client will not be gzipped, but an Accept header will be added and, if the server supports GZIP compression, the response will be gzipped and any subsequent requests will be also. Section 24.3.4.11, "@GZIP Properties" shows the optional properties supported by the @GZIP annotation. 24.3.4.11. @GZIP Properties Property Description threshold Messages smaller than the size specified by this property are not gzipped. Default is -1 (no limit). @FastInfoset The @FastInfoset annotation is defined by the org.apache.cxf.annotations.FastInfoset interface. It is placed on the SEI. Enables the use of FastInfoset format for messages. FastInfoset is a binary encoding format for XML, which aims to optimize both the message size and the processing performance of XML messages. For more details, see the following Sun article on Fast Infoset . FastInfoset is a negotiated enhancement. That is, an initial request from a client will not be in FastInfoset format, but an Accept header will be added and, if the server supports FastInfoset, the response will be in FastInfoset and any subsequent requests will be also. Section 24.3.4.12, "@FastInfoset Properties" shows the optional properties supported by the @FastInfoset annotation. 24.3.4.12. @FastInfoset Properties Property Description force A boolean property that forces the use of FastInfoset format, instead of negotiating. When true , force the use of FastInfoset format; otherwise, negotiate. Default is false . Example of @GZIP Section 24.3.4.13, "Enabling GZIP" shows how to enable GZIP compression for the HelloWorld SEI. 24.3.4.13. Enabling GZIP Exampe of @FastInfoset Section 24.3.4.14, "Enabling FastInfoset" shows how to enable the FastInfoset format for the HelloWorld SEI. 24.3.4.14. Enabling FastInfoset 24.3.4.15. Enable Logging on an Endpoint @Logging annotation The @Logging annotation is defined by the org.apache.cxf.annotations.Logging interface. It is placed on the SEI. This annotation enables logging for all endpoints associated with the SEI. Section 24.3.4.16, "@Logging Properties" shows the optional properties you can set in this annotation. 24.3.4.16. @Logging Properties Property Description limit Specifies the size limit, beyond which the message is truncated in the logs. Default is 64K. inLocation Specifies the location to log incoming messages. Can be either <stderr> , <stdout> , <logger> , or a filename. Default is <logger> . outLocation Specifies the location to log outgoing messages. Can be either <stderr> , <stdout> , <logger> , or a filename. Default is <logger> . Example Section 24.3.4.17, "Logging configuration using annotations" shows how to enable logging for the HelloWorld SEI, where incoming messages are sent to <stdout> and outgoing messages are sent to <logger> . 24.3.4.17. Logging configuration using annotations 24.3.4.18. Adding Properties and Policies to an Endpoint Abstract Both properties and policies can be used to associate configuration data with an endpoint. The essential difference between them is that properties are a Apache CXF specific configuration mechanism whereas policies are a standard WSDL configuration mechanism. Policies typically originate from WS specifications and standards and they are normally set by defining wsdl:policy elements that appear in the WSDL contract. By contrast, properties are Apache CXF-specific and they are normally set by defining jaxws:properties elements in the Apache CXF Spring configuration file. It is also possible, however, to define property settings and WSDL policy settings in Java using annotations, as described here. 24.3.4.19. Adding properties @EndpointProperty annotation The @EndpointProperty annotation is defined by the org.apache.cxf.annotations.EndpointProperty interface. It is placed on the SEI. This annotation adds Apache CXF-specific configuration settings to an endpoint. Endpoint properties can also be specified in a Spring configuration file. For example, to configure WS-Security on an endpoint, you could add endpoint properties using the jaxws:properties element in a Spring configuration file as follows: Alternatively, you could specify the preceding configuration settings in Java by adding @EndpointProperty annotations to the SEI, as shown in Section 24.3.4.20, "Configuring WS-Security Using @EndpointProperty Annotations" . 24.3.4.20. Configuring WS-Security Using @EndpointProperty Annotations @EndpointProperties annotation The @EndpointProperties annotation is defined by the org.apache.cxf.annotations.EndpointProperties interface. It is placed on the SEI. This annotation provides a way of grouping multiple @EndpointProperty annotations into a list. Using @EndpointProperties , it is possible to re-write Section 24.3.4.20, "Configuring WS-Security Using @EndpointProperty Annotations" as shown in Section 24.3.4.21, "Configuring WS-Security Using an @EndpointProperties Annotation" . 24.3.4.21. Configuring WS-Security Using an @EndpointProperties Annotation 24.3.4.22. Adding policies @Policy annotation The @Policy annotation is defined by the org.apache.cxf.annotations.Policy interface. It can be placed on the SEI or the SEI methods. This annotation is used to associate a WSDL policy with an SEI or an SEI method. The policy is specified by providing a URI that references an XML file containing a standard wsdl:policy element. If a WSDL contract is to be generated from the SEI (for example, using the java2ws command-line tool), you can specify whether or not you want to include this policy in the WSDL. Section 24.3.4.23, "@Policy Properties" shows the properties supported by the @Policy annotation. 24.3.4.23. @Policy Properties Property Description uri (Required) The location of the file containing the policy definition. includeInWSDL (Optional) Whether to include the policy in the generated contract, when generating WSDL. Default is true . placement (Optional) Specifies where in the WSDL file this documentation is to appear. For the list of possible placement values, see the section called "Placement in the WSDL contract" . faultClass (Optional) If the placement is set to be BINDING_OPERATION_FAULT or PORT_TYPE_OPERATION_FAULT , you must also set this property to specify which fault this policy applies to. The value is the Java class that represents the fault. @Policies annotation The @Policies annotation is defined by the org.apache.cxf.annotations.Policies interface. It can be placed on the SEI or thse SEI methods. This annotation provides a way of grouping multiple @Policy annotations into a list. Placement in the WSDL contract To specify where the policy should appear in the WSDL contract, you can specify the placement property, which is of type Policy.Placement . The placement can have one of the following values: Example of @Policy The following example shows how to associate WSDL policies with the HelloWorld SEI and how to associate a policy with the sayHi method. The policies themselves are stored in XML files in the file system, under the annotationpolicies directory. Example of @Policies You can use the @Policies annotation to group multiple @Policy annotations into a list, as shown in the following example: 24.4. Generating WSDL Using Maven Once your code is annotated, you can generate a WSDL contract for your service using the java2ws Maven plug-in's -wsdl option. For a detailed listing of options for the java2ws Maven plug-in see Section 44.3, "java2ws" . Example 24.8, "Generating WSDL from Java" shows how to set up the java2ws Maven plug-in to generate WSDL. Example 24.8. Generating WSDL from Java Note Replace the value of className with the qualified className. Example Example 24.9, "Generated WSDL from an SEI " shows the WSDL contract that is generated for the SEI shown in Example 24.7, "Fully Annotated SEI" . Example 24.9. Generated WSDL from an SEI [1] Board is an assumed class whose implementation is left to the reader.	[ "package com.fusesource.demo; public interface quoteReporter { public Quote getQuote(String ticker); }", "package com.fusesource.demo; import java.util.; public class stockQuoteReporter implements quoteReporter { public Quote getQuote(String ticker) { Quote retVal = new Quote(); retVal.setID(ticker); retVal.setVal(Board.check(ticker)); [1] Date retDate = new Date(); retVal.setTime(retDate.toString()); return(retVal); } }", "package com.fusesource.demo; import javax.jws.; @WebService(name=\"quoteUpdater\", targetNamespace=\"http://demos.redhat.com\", serviceName=\"updateQuoteService\", wsdlLocation=\"http://demos.redhat.com/quoteExampleService?wsdl\", portName=\"updateQuotePort\") public interface quoteReporter { public Quote getQuote(String ticker); }", "package org.eric.demo; import javax.jws.; @WebService(endpointInterface=\"com.fusesource.demo.quoteReporter\") public class stockQuoteReporter implements quoteReporter { public Quote getQuote(String ticker) { } }", "package org.eric.demo; import javax.jws.; import javax.jws.soap.; import javax.jws.soap.SOAPBinding.; @WebService(name=\"quoteReporter\") @SOAPBinding(parameterStyle=ParameterStyle.BARE) public interface quoteReporter { }", "package com.fusesource.demo; import javax.jws.; import javax.xml.ws.; @WebService(name=\"quoteReporter\") public interface quoteReporter { @WebMethod(operationName=\"getStockQuote\") @RequestWrapper(targetNamespace=\"http://demo.redhat.com/types\", className=\"java.lang.String\") @ResponseWrapper(targetNamespace=\"http://demo.redhat.com/types\", className=\"org.eric.demo.Quote\") public Quote getQuote(String ticker); }", "package com.fusesource.demo; import javax.jws.; import javax.xml.ws.; import javax.jws.soap.; import javax.jws.soap.SOAPBinding.; import javax.jws.WebParam.*; @WebService(targetNamespace=\"http://demo.redhat.com\", name=\"quoteReporter\") @SOAPBinding(style=Style.RPC, use=Use.LITERAL) public interface quoteReporter { @WebMethod(operationName=\"getStockQuote\") @RequestWrapper(targetNamespace=\"http://demo.redhat.com/types\", className=\"java.lang.String\") @ResponseWrapper(targetNamespace=\"http://demo.redhat.com/types\", className=\"org.eric.demo.Quote\") @WebResult(targetNamespace=\"http://demo.redhat.com/types\", name=\"updatedQuote\") public Quote getQuote( @WebParam(targetNamespace=\"http://demo.redhat.com/types\", name=\"stockTicker\", mode=Mode.IN) String ticker ); }", "@WebService @WSDLDocumentation(\"A very simple example of an SEI\") public interface HelloWorld { @WSDLDocumentation(\"A traditional form of greeting\") String sayHi(@WebParam(name = \"text\") String text); }", "<wsdl:definitions ... > <wsdl:portType name=\"HelloWorld\"> <wsdl:documentation>A very simple example of an SEI</wsdl:documentation> <wsdl:operation name=\"sayHi\"> <wsdl:documentation>A traditional form of greeting</wsdl:documentation> <wsdl:input name=\"sayHi\" message=\"tns:sayHi\"> </wsdl:input> <wsdl:output name=\"sayHiResponse\" message=\"tns:sayHiResponse\"> </wsdl:output> </wsdl:operation> </wsdl:portType> </wsdl:definitions>", "@WebService @WSDLDocumentationCollection( { @WSDLDocumentation(\"A very simple example of an SEI\"), @WSDLDocumentation(value = \"My top level documentation\", placement = WSDLDocumentation.Placement.TOP), @WSDLDocumentation(value = \"Binding documentation\", placement = WSDLDocumentation.Placement.BINDING) } ) public interface HelloWorld { @WSDLDocumentation(\"A traditional form of Geeky greeting\") String sayHi(@WebParam(name = \"text\") String text); }", "@WebService @SchemaValidation(type = SchemaValidationType.BOTH) public interface MyService { Foo validateBoth(Bar data); @SchemaValidation(type = SchemaValidationType.NONE) Foo validateNone(Bar data); @SchemaValidation(type = SchemaValidationType.IN) Foo validateIn(Bar data); @SchemaValidation(type = SchemaValidationType.OUT) Foo validateOut(Bar data); @SchemaValidation(type = SchemaValidationType.REQUEST) Foo validateRequest(Bar data); @SchemaValidation(type = SchemaValidationType.RESPONSE) Foo validateResponse(Bar data); }", "@WebService @DataBinding(org.apache.cxf.sdo.SDODataBinding.class) public interface HelloWorld { String sayHi(@WebParam(name = \"text\") String text); }", "@WebService @GZIP public interface HelloWorld { String sayHi(@WebParam(name = \"text\") String text); }", "@WebService @FastInfoset public interface HelloWorld { String sayHi(@WebParam(name = \"text\") String text); }", "@WebService @Logging(limit=16000, inLocation=\"<stdout>\") public interface HelloWorld { String sayHi(@WebParam(name = \"text\") String text); }", "<beans xmlns=\"http://www.springframework.org/schema/beans\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:jaxws=\"http://cxf.apache.org/jaxws\" ... > <jaxws:endpoint id=\"MyService\" address=\"https://localhost:9001/MyService\" serviceName=\"interop:MyService\" endpointName=\"interop:MyServiceEndpoint\" implementor=\"com.foo.MyService\"> <jaxws:properties> <entry key=\"ws-security.callback-handler\" value=\"interop.client.UTPasswordCallback\"/> <entry key=\"ws-security.signature.properties\" value=\"etc/keystore.properties\"/> <entry key=\"ws-security.encryption.properties\" value=\"etc/truststore.properties\"/> <entry key=\"ws-security.encryption.username\" value=\"useReqSigCert\"/> </jaxws:properties> </jaxws:endpoint> </beans>", "@WebService @EndpointProperty(name=\"ws-security.callback-handler\" value=\"interop.client.UTPasswordCallback\") @EndpointProperty(name=\"ws-security.signature.properties\" value=\"etc/keystore.properties\") @EndpointProperty(name=\"ws-security.encryption.properties\" value=\"etc/truststore.properties\") @EndpointProperty(name=\"ws-security.encryption.username\" value=\"useReqSigCert\") public interface HelloWorld { String sayHi(@WebParam(name = \"text\") String text); }", "@WebService @EndpointProperties( { @EndpointProperty(name=\"ws-security.callback-handler\" value=\"interop.client.UTPasswordCallback\"), @EndpointProperty(name=\"ws-security.signature.properties\" value=\"etc/keystore.properties\"), @EndpointProperty(name=\"ws-security.encryption.properties\" value=\"etc/truststore.properties\"), @EndpointProperty(name=\"ws-security.encryption.username\" value=\"useReqSigCert\") }) public interface HelloWorld { String sayHi(@WebParam(name = \"text\") String text); }", "Policy.Placement.BINDING Policy.Placement.BINDING_OPERATION Policy.Placement.BINDING_OPERATION_FAULT Policy.Placement.BINDING_OPERATION_INPUT Policy.Placement.BINDING_OPERATION_OUTPUT Policy.Placement.DEFAULT Policy.Placement.PORT_TYPE Policy.Placement.PORT_TYPE_OPERATION Policy.Placement.PORT_TYPE_OPERATION_FAULT Policy.Placement.PORT_TYPE_OPERATION_INPUT Policy.Placement.PORT_TYPE_OPERATION_OUTPUT Policy.Placement.SERVICE Policy.Placement.SERVICE_PORT", "@WebService @Policy(uri = \"annotationpolicies/TestImplPolicy.xml\", placement = Policy.Placement.SERVICE_PORT), @Policy(uri = \"annotationpolicies/TestPortTypePolicy.xml\", placement = Policy.Placement.PORT_TYPE) public interface HelloWorld { @Policy(uri = \"annotationpolicies/TestOperationPTPolicy.xml\", placement = Policy.Placement.PORT_TYPE_OPERATION), String sayHi(@WebParam(name = \"text\") String text); }", "@WebService @Policies({ @Policy(uri = \"annotationpolicies/TestImplPolicy.xml\", placement = Policy.Placement.SERVICE_PORT), @Policy(uri = \"annotationpolicies/TestPortTypePolicy.xml\", placement = Policy.Placement.PORT_TYPE) }) public interface HelloWorld { @Policy(uri = \"annotationpolicies/TestOperationPTPolicy.xml\", placement = Policy.Placement.PORT_TYPE_OPERATION), String sayHi(@WebParam(name = \"text\") String text); }", "<plugin> <groupId>org.apache.cxf</groupId> <artifactId>cxf-java2ws-plugin</artifactId> <version>USD{cxf.version}</version> <executions> <execution> <id>process-classes</id> <phase>process-classes</phase> <configuration> <className> className </className> <genWsdl>true</genWsdl> </configuration> <goals> <goal>java2ws</goal> </goals> </execution> </executions> </plugin>", "<?xml version=\"1.0\" encoding=\"UTF-8\"?> <wsdl:definitions targetNamespace=\"http://demo.eric.org/\" xmlns:tns=\"http://demo.eric.org/\" xmlns:ns1=\"\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:ns2=\"http://demo.eric.org/types\" xmlns:soap=\"http://schemas.xmlsoap.org/wsdl/soap/\" xmlns:wsdl=\"http://schemas.xmlsoap.org/wsdl/\"> <wsdl:types> <xsd:schema> <xs:complexType name=\"quote\"> <xs:sequence> <xs:element name=\"ID\" type=\"xs:string\" minOccurs=\"0\"/> <xs:element name=\"time\" type=\"xs:string\" minOccurs=\"0\"/> <xs:element name=\"val\" type=\"xs:float\"/> </xs:sequence> </xs:complexType> </xsd:schema> </wsdl:types> <wsdl:message name=\"getStockQuote\"> <wsdl:part name=\"stockTicker\" type=\"xsd:string\"> </wsdl:part> </wsdl:message> <wsdl:message name=\"getStockQuoteResponse\"> <wsdl:part name=\"updatedQuote\" type=\"tns:quote\"> </wsdl:part> </wsdl:message> <wsdl:portType name=\"quoteReporter\"> <wsdl:operation name=\"getStockQuote\"> <wsdl:input name=\"getQuote\" message=\"tns:getStockQuote\"> </wsdl:input> <wsdl:output name=\"getQuoteResponse\" message=\"tns:getStockQuoteResponse\"> </wsdl:output> </wsdl:operation> </wsdl:portType> <wsdl:binding name=\"quoteReporterBinding\" type=\"tns:quoteReporter\"> <soap:binding style=\"rpc\" transport=\"http://schemas.xmlsoap.org/soap/http\" /> <wsdl:operation name=\"getStockQuote\"> <soap:operation style=\"rpc\" /> <wsdl:input name=\"getQuote\"> <soap:body use=\"literal\" /> </wsdl:input> <wsdl:output name=\"getQuoteResponse\"> <soap:body use=\"literal\"/> </wsdl:output> </wsdl:operation> </wsdl:binding> <wsdl:service name=\"quoteReporterService\"> <wsdl:port name=\"quoteReporterPort\" binding=\"tns:quoteReporterBinding\"> <soap:address location=\"http://localhost:9000/quoteReporterService\" /> </wsdl:port> </wsdl:service> </wsdl:definitions>" ]	https://docs.redhat.com/en/documentation/red_hat_fuse/7.13/html/apache_cxf_development_guide/jaxwsservicedevjavafirst
Chapter 8. Sources	Chapter 8. Sources The updated Red Hat Ceph Storage source code packages are available at the following location: For Red Hat Enterprise Linux 9: https://ftp.redhat.com/redhat/linux/enterprise/9Base/en/RHCEPH/SRPMS/	null	https://docs.redhat.com/en/documentation/red_hat_ceph_storage/7/html/release_notes/sources
Chapter 100. Mock	Chapter 100. Mock Only producer is supported Testing of distributed and asynchronous processing is notoriously difficult. The Mock , Test and Dataset endpoints work great with the Camel Testing Framework to simplify your unit and integration testing using Enterprise Integration Patterns and Camel's large range of Components together with the powerful Bean Integration. The Mock component provides a powerful declarative testing mechanism, which is similar to jMock in that it allows declarative expectations to be created on any Mock endpoint before a test begins. Then the test is run, which typically fires messages to one or more endpoints, and finally the expectations can be asserted in a test case to ensure the system worked as expected. This allows you to test various things like: The correct number of messages are received on each endpoint, The correct payloads are received, in the right order, Messages arrive on an endpoint in order, using some Expression to create an order testing function, Messages arrive match some kind of Predicate such as that specific headers have certain values, or that messages match some predicate, such as by evaluating an XPath or XQuery Expression. Note There is also the Test endpoint which is a Mock endpoint, but which uses a second endpoint to provide the list of expected message bodies and automatically sets up the Mock endpoint assertions. In other words, it's a Mock endpoint that automatically sets up its assertions from some sample messages in a File or database , for example. Note Mock endpoints keep received Exchanges in memory indefinitely. Remember that Mock is designed for testing. When you add Mock endpoints to a route, each Exchange sent to the endpoint will be stored (to allow for later validation) in memory until explicitly reset or the JVM is restarted. If you are sending high volume and/or large messages, this may cause excessive memory use. If your goal is to test deployable routes inline, consider using NotifyBuilder or AdviceWith in your tests instead of adding Mock endpoints to routes directly. There are two new options retainFirst, and retainLast that can be used to limit the number of messages the Mock endpoints keep in memory. 100.1. Dependencies When using mock with Red Hat build of Camel Spring Boot make sure to use the following Maven dependency to have support for auto configuration: <dependency> <groupId>org.apache.camel.springboot</groupId> <artifactId>camel-mock-starter</artifactId> </dependency> 100.2. URI format Where someName can be any string that uniquely identifies the endpoint. 100.3. Configuring Options Camel components are configured on two separate levels: component level endpoint level 100.3.1. Configuring Component Options At the component level, you set general and shared configurations that are, then, inherited by the endpoints. It is the highest configuration level. For example, a component may have security settings, credentials for authentication, urls for network connection and so forth. Some components only have a few options, and others may have many. Because components typically have pre-configured defaults that are commonly used, then you may often only need to configure a few options on a component; or none at all. You can configure components using: the Component DSL . in a configuration file (application.properties, .yaml files, etc). directly in the Java code. 100.3.2. Configuring Endpoint Options You usually spend more time setting up endpoints because they have many options. These options help you customize what you want the endpoint to do. The options are also categorized into whether the endpoint is used as a consumer (from), as a producer (to), or both. Configuring endpoints is most often done directly in the endpoint URI as path and query parameters. You can also use the Endpoint DSL and DataFormat DSL as a type safe way of configuring endpoints and data formats in Java. A good practice when configuring options is to use Property Placeholders . Property placeholders provide a few benefits: They help prevent using hardcoded urls, port numbers, sensitive information, and other settings. They allow externalizing the configuration from the code. They help the code to become more flexible and reusable. The following two sections list all the options, firstly for the component followed by the endpoint. 100.4. Component Options The Mock component supports 4 options, which are listed below. Name Description Default Type lazyStartProducer (producer) Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. false boolean log (producer) To turn on logging when the mock receives an incoming message. This will log only one time at INFO level for the incoming message. For more detailed logging then set the logger to DEBUG level for the org.apache.camel.component.mock.MockEndpoint class. false boolean autowiredEnabled (advanced) Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc. true boolean exchangeFormatter (advanced) Autowired Sets a custom ExchangeFormatter to convert the Exchange to a String suitable for logging. If not specified, we default to DefaultExchangeFormatter. ExchangeFormatter 100.5. Endpoint Options The Mock endpoint is configured using URI syntax: with the following path and query parameters: 100.5.1. Path Parameters (1 parameters) Name Description Default Type name (producer) Required Name of mock endpoint. String 100.5.2. Query Parameters (12 parameters) Name Description Default Type assertPeriod (producer) Sets a grace period after which the mock endpoint will re-assert to ensure the preliminary assertion is still valid. This is used for example to assert that exactly a number of messages arrives. For example if expectedMessageCount(int) was set to 5, then the assertion is satisfied when 5 or more message arrives. To ensure that exactly 5 messages arrives, then you would need to wait a little period to ensure no further message arrives. This is what you can use this method for. By default this period is disabled. long expectedCount (producer) Specifies the expected number of message exchanges that should be received by this endpoint. Beware: If you want to expect that 0 messages, then take extra care, as 0 matches when the tests starts, so you need to set a assert period time to let the test run for a while to make sure there are still no messages arrived; for that use setAssertPeriod(long). An alternative is to use NotifyBuilder, and use the notifier to know when Camel is done routing some messages, before you call the assertIsSatisfied() method on the mocks. This allows you to not use a fixed assert period, to speedup testing times. If you want to assert that exactly n'th message arrives to this mock endpoint, then see also the setAssertPeriod(long) method for further details. -1 int failFast (producer) Sets whether assertIsSatisfied() should fail fast at the first detected failed expectation while it may otherwise wait for all expected messages to arrive before performing expectations verifications. Is by default true. Set to false to use behavior as in Camel 2.x. false boolean lazyStartProducer (producer) Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. false boolean log (producer) To turn on logging when the mock receives an incoming message. This will log only one time at INFO level for the incoming message. For more detailed logging then set the logger to DEBUG level for the org.apache.camel.component.mock.MockEndpoint class. false boolean reportGroup (producer) A number that is used to turn on throughput logging based on groups of the size. int resultMinimumWaitTime (producer) Sets the minimum expected amount of time (in millis) the assertIsSatisfied() will wait on a latch until it is satisfied. long resultWaitTime (producer) Sets the maximum amount of time (in millis) the assertIsSatisfied() will wait on a latch until it is satisfied. long retainFirst (producer) Specifies to only retain the first n'th number of received Exchanges. This is used when testing with big data, to reduce memory consumption by not storing copies of every Exchange this mock endpoint receives. Important: When using this limitation, then the getReceivedCounter() will still return the actual number of received Exchanges. For example if we have received 5000 Exchanges, and have configured to only retain the first 10 Exchanges, then the getReceivedCounter() will still return 5000 but there is only the first 10 Exchanges in the getExchanges() and getReceivedExchanges() methods. When using this method, then some of the other expectation methods is not supported, for example the expectedBodiesReceived(Object... ) sets a expectation on the first number of bodies received. You can configure both setRetainFirst(int) and setRetainLast(int) methods, to limit both the first and last received. -1 int retainLast (producer) Specifies to only retain the last n'th number of received Exchanges. This is used when testing with big data, to reduce memory consumption by not storing copies of every Exchange this mock endpoint receives. Important: When using this limitation, then the getReceivedCounter() will still return the actual number of received Exchanges. For example if we have received 5000 Exchanges, and have configured to only retain the last 20 Exchanges, then the getReceivedCounter() will still return 5000 but there is only the last 20 Exchanges in the getExchanges() and getReceivedExchanges() methods. When using this method, then some of the other expectation methods is not supported, for example the expectedBodiesReceived(Object... ) sets a expectation on the first number of bodies received. You can configure both setRetainFirst(int) and setRetainLast(int) methods, to limit both the first and last received. -1 int sleepForEmptyTest (producer) Allows a sleep to be specified to wait to check that this endpoint really is empty when expectedMessageCount(int) is called with zero. long copyOnExchange (producer (advanced)) Sets whether to make a deep copy of the incoming Exchange when received at this mock endpoint. Is by default true. true boolean 100.6. Simple Example Here's a simple example of Mock endpoint in use. First, the endpoint is resolved on the context. Then we set an expectation, and then, after the test has run, we assert that our expectations have been met: MockEndpoint resultEndpoint = context.getEndpoint("mock:foo", MockEndpoint.class); // set expectations resultEndpoint.expectedMessageCount(2); // send some messages // now lets assert that the mock:foo endpoint received 2 messages resultEndpoint.assertIsSatisfied(); You typically always call the method to test that the expectations were met after running a test. Camel will by default wait 10 seconds when the assertIsSatisfied() is invoked. This can be configured by setting the setResultWaitTime(millis) method. 100.7. Using assertPeriod When the assertion is satisfied then Camel will stop waiting and continue from the assertIsSatisfied method. That means if a new message arrives on the mock endpoint, just a bit later, that arrival will not affect the outcome of the assertion. Suppose you do want to test that no new messages arrives after a period thereafter, then you can do that by setting the setAssertPeriod method, for example: MockEndpoint resultEndpoint = context.getEndpoint("mock:foo", MockEndpoint.class); resultEndpoint.setAssertPeriod(5000); resultEndpoint.expectedMessageCount(2); // send some messages // now lets assert that the mock:foo endpoint received 2 messages resultEndpoint.assertIsSatisfied(); 100.8. Setting expectations You can see from the Javadoc of MockEndpoint the various helper methods you can use to set expectations. The main methods are as follows: Method Description expectedMessageCount(int) To define the expected message count on the endpoint. expectedMinimumMessageCount(int) To define the minimum number of expected messages on the endpoint. expectedBodiesReceived(... ) To define the expected bodies that should be received (in order). expectedHeaderReceived(... ) To define the expected header that should be received expectsAscending(Expression) To add an expectation that messages are received in order, using the given Expression to compare messages. expectsDescending(Expression) To add an expectation that messages are received in order, using the given Expression to compare messages. expectsNoDuplicates(Expression) To add an expectation that no duplicate messages are received; using an Expression to calculate a unique identifier for each message. This could be something like the JMSMessageID if using JMS, or some unique reference number within the message. Here's another example: resultEndpoint.expectedBodiesReceived("firstMessageBody", "secondMessageBody", "thirdMessageBody"); 100.9. Adding expectations to specific messages In addition, you can use the message(int messageIndex) method to add assertions about a specific message that is received. For example, to add expectations of the headers or body of the first message (using zero-based indexing like java.util.List ), you can use the following code: resultEndpoint.message(0).header("foo").isEqualTo("bar"); There are some examples of the Mock endpoint in use in the camel-core processor tests . 100.10. Mocking existing endpoints Camel now allows you to automatically mock existing endpoints in your Camel routes. Note How it works The endpoints are still in action. What happens differently is that a Mock endpoint is injected and receives the message first and then delegates the message to the target endpoint. You can view this as a kind of intercept and delegate or endpoint listener. Suppose you have the given route below: Route @Override protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { @Override public void configure() throws Exception { from("direct:start").routeId("start") .to("direct:foo").to("log:foo").to("mock:result"); from("direct:foo").routeId("foo") .transform(constant("Bye World")); } }; } You can then use the adviceWith feature in Camel to mock all the endpoints in a given route from your unit test, as shown below: adviceWith mocking all endpoints @Test public void testAdvisedMockEndpoints() throws Exception { // advice the start route using the inlined AdviceWith lambda style route builder // which has extended capabilities than the regular route builder AdviceWith.adviceWith(context, "start", a -> // mock all endpoints a.mockEndpoints()); getMockEndpoint("mock:direct:start").expectedBodiesReceived("Hello World"); getMockEndpoint("mock:direct:foo").expectedBodiesReceived("Hello World"); getMockEndpoint("mock:log:foo").expectedBodiesReceived("Bye World"); getMockEndpoint("mock:result").expectedBodiesReceived("Bye World"); template.sendBody("direct:start", "Hello World"); assertMockEndpointsSatisfied(); // additional test to ensure correct endpoints in registry assertNotNull(context.hasEndpoint("direct:start")); assertNotNull(context.hasEndpoint("direct:foo")); assertNotNull(context.hasEndpoint("log:foo")); assertNotNull(context.hasEndpoint("mock:result")); // all the endpoints was mocked assertNotNull(context.hasEndpoint("mock:direct:start")); assertNotNull(context.hasEndpoint("mock:direct:foo")); assertNotNull(context.hasEndpoint("mock:log:foo")); } Notice that the mock endpoints is given the URI mock:<endpoint> , for example mock:direct:foo . Camel logs at INFO level the endpoints being mocked: Note Mocked endpoints are without parameters Endpoints which are mocked will have their parameters stripped off. For example the endpoint log:foo?showAll=true will be mocked to the following endpoint mock:log:foo . Notice the parameters have been removed. Its also possible to only mock certain endpoints using a pattern. For example to mock all log endpoints you do as shown: adviceWith mocking only log endpoints using a pattern @Test public void testAdvisedMockEndpointsWithPattern() throws Exception { // advice the start route using the inlined AdviceWith lambda style route builder // which has extended capabilities than the regular route builder AdviceWith.adviceWith(context, "start", a -> // mock only log endpoints a.mockEndpoints("log")); // now we can refer to log:foo as a mock and set our expectations getMockEndpoint("mock:log:foo").expectedBodiesReceived("Bye World"); getMockEndpoint("mock:result").expectedBodiesReceived("Bye World"); template.sendBody("direct:start", "Hello World"); assertMockEndpointsSatisfied(); // additional test to ensure correct endpoints in registry assertNotNull(context.hasEndpoint("direct:start")); assertNotNull(context.hasEndpoint("direct:foo")); assertNotNull(context.hasEndpoint("log:foo")); assertNotNull(context.hasEndpoint("mock:result")); // only the log:foo endpoint was mocked assertNotNull(context.hasEndpoint("mock:log:foo")); assertNull(context.hasEndpoint("mock:direct:start")); assertNull(context.hasEndpoint("mock:direct:foo")); } The pattern supported can be a wildcard or a regular expression. See more details about this at Intercept as its the same matching function used by Camel. Note Mind that mocking endpoints causes the messages to be copied when they arrive on the mock. That means Camel will use more memory. This may not be suitable when you send in a lot of messages. 100.11. Mocking existing endpoints using the camel-test component Instead of using the adviceWith to instruct Camel to mock endpoints, you can easily enable this behavior when using the camel-test Test Kit. The same route can be tested as follows. Notice that we return "" from the isMockEndpoints method, which tells Camel to mock all endpoints. If you only want to mock all log endpoints you can return "log" instead. isMockEndpoints using camel-test kit public class IsMockEndpointsJUnit4Test extends CamelTestSupport { @Override public String isMockEndpoints() { // override this method and return the pattern for which endpoints to mock. // use * to indicate all return ""; } @Test public void testMockAllEndpoints() throws Exception { // notice we have automatic mocked all endpoints and the name of the endpoints is "mock:uri" getMockEndpoint("mock:direct:start").expectedBodiesReceived("Hello World"); getMockEndpoint("mock:direct:foo").expectedBodiesReceived("Hello World"); getMockEndpoint("mock:log:foo").expectedBodiesReceived("Bye World"); getMockEndpoint("mock:result").expectedBodiesReceived("Bye World"); template.sendBody("direct:start", "Hello World"); assertMockEndpointsSatisfied(); // additional test to ensure correct endpoints in registry assertNotNull(context.hasEndpoint("direct:start")); assertNotNull(context.hasEndpoint("direct:foo")); assertNotNull(context.hasEndpoint("log:foo")); assertNotNull(context.hasEndpoint("mock:result")); // all the endpoints was mocked assertNotNull(context.hasEndpoint("mock:direct:start")); assertNotNull(context.hasEndpoint("mock:direct:foo")); assertNotNull(context.hasEndpoint("mock:log:foo")); } @Override protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { @Override public void configure() throws Exception { from("direct:start").to("direct:foo").to("log:foo").to("mock:result"); from("direct:foo").transform(constant("Bye World")); } }; } } 100.12. Mocking existing endpoints with XML DSL If you do not use the camel-test component for unit testing (as shown above) you can use a different approach when using XML files for routes. The solution is to create a new XML file used by the unit test and then include the intended XML file which has the route you want to test. Suppose we have the route in the camel-route.xml file: camel-route.xml <!-- this camel route is in the camel-route.xml file --> <camelContext xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="direct:start"/> <to uri="direct:foo"/> <to uri="log:foo"/> <to uri="mock:result"/> </route> <route> <from uri="direct:foo"/> <transform> <constant>Bye World</constant> </transform> </route> </camelContext> Then we create a new XML file as follows, where we include the camel-route.xml file and define a spring bean with the class org.apache.camel.impl.InterceptSendToMockEndpointStrategy which tells Camel to mock all endpoints: test-camel-route.xml <!-- the Camel route is defined in another XML file --> <import resource="camel-route.xml"/> <!-- bean which enables mocking all endpoints --> <bean id="mockAllEndpoints" class="org.apache.camel.component.mock.InterceptSendToMockEndpointStrategy"/> Then in your unit test you load the new XML file ( test-camel-route.xml ) instead of camel-route.xml . To only mock all Log endpoints you can define the pattern in the constructor for the bean: <bean id="mockAllEndpoints" class="org.apache.camel.impl.InterceptSendToMockEndpointStrategy"> <constructor-arg index="0" value="log"/> </bean> 100.13. Mocking endpoints and skip sending to original endpoint Sometimes you want to easily mock and skip sending to a certain endpoints. So the message is detoured and send to the mock endpoint only. You can now use the mockEndpointsAndSkip method using AdviceWith. The example below will skip sending to the two endpoints "direct:foo" , and "direct:bar" . adviceWith mock and skip sending to endpoints @Test public void testAdvisedMockEndpointsWithSkip() throws Exception { // advice the first route using the inlined AdviceWith route builder // which has extended capabilities than the regular route builder AdviceWith.adviceWith(context.getRouteDefinitions().get(0), context, new AdviceWithRouteBuilder() { @Override public void configure() throws Exception { // mock sending to direct:foo and direct:bar and skip send to it mockEndpointsAndSkip("direct:foo", "direct:bar"); } }); getMockEndpoint("mock:result").expectedBodiesReceived("Hello World"); getMockEndpoint("mock:direct:foo").expectedMessageCount(1); getMockEndpoint("mock:direct:bar").expectedMessageCount(1); template.sendBody("direct:start", "Hello World"); assertMockEndpointsSatisfied(); // the message was not send to the direct:foo route and thus not sent to // the seda endpoint SedaEndpoint seda = context.getEndpoint("seda:foo", SedaEndpoint.class); assertEquals(0, seda.getCurrentQueueSize()); } The same example using the Test Kit isMockEndpointsAndSkip using camel-test kit public class IsMockEndpointsAndSkipJUnit4Test extends CamelTestSupport { @Override public String isMockEndpointsAndSkip() { // override this method and return the pattern for which endpoints to mock, // and skip sending to the original endpoint. return "direct:foo"; } @Test public void testMockEndpointAndSkip() throws Exception { // notice we have automatic mocked the direct:foo endpoints and the name of the endpoints is "mock:uri" getMockEndpoint("mock:result").expectedBodiesReceived("Hello World"); getMockEndpoint("mock:direct:foo").expectedMessageCount(1); template.sendBody("direct:start", "Hello World"); assertMockEndpointsSatisfied(); // the message was not send to the direct:foo route and thus not sent to the seda endpoint SedaEndpoint seda = context.getEndpoint("seda:foo", SedaEndpoint.class); assertEquals(0, seda.getCurrentQueueSize()); } @Override protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { @Override public void configure() throws Exception { from("direct:start").to("direct:foo").to("mock:result"); from("direct:foo").transform(constant("Bye World")).to("seda:foo"); } }; } } 100.14. Limiting the number of messages to keep The Mock endpoints will by default keep a copy of every Exchange that it received. So if you test with a lot of messages, then it will consume memory. We have introduced two options retainFirst and retainLast that can be used to specify to only keep N'th of the first and/or last Exchanges. For example in the code below, we only want to retain a copy of the first 5 and last 5 Exchanges the mock receives. MockEndpoint mock = getMockEndpoint("mock:data"); mock.setRetainFirst(5); mock.setRetainLast(5); mock.expectedMessageCount(2000); mock.assertIsSatisfied(); Using this has some limitations. The getExchanges() and getReceivedExchanges() methods on the MockEndpoint will return only the retained copies of the Exchanges. So in the example above, the list will contain 10 Exchanges; the first five, and the last five. The retainFirst and retainLast options also have limitations on which expectation methods you can use. For example the expectedXXX methods that work on message bodies, headers, etc. will only operate on the retained messages. In the example above they can test only the expectations on the 10 retained messages. 100.15. Testing with arrival times The Mock endpoint stores the arrival time of the message as a property on the Exchange Date time = exchange.getProperty(Exchange.RECEIVED_TIMESTAMP, Date.class); You can use this information to know when the message arrived on the mock. But it also provides foundation to know the time interval between the and message arrived on the mock. You can use this to set expectations using the arrives DSL on the Mock endpoint. For example to say that the first message should arrive between 0-2 seconds before the you can do: mock.message(0).arrives().noLaterThan(2).seconds().beforeNext(); You can also define this as that 2nd message (0 index based) should arrive no later than 0-2 seconds after the : mock.message(1).arrives().noLaterThan(2).seconds().afterPrevious(); You can also use between to set a lower bound. For example suppose that it should be between 1-4 seconds: mock.message(1).arrives().between(1, 4).seconds().afterPrevious(); You can also set the expectation on all messages, for example to say that the gap between them should be at most 1 second: mock.allMessages().arrives().noLaterThan(1).seconds().beforeNext(); Note Time units In the example above we use seconds as the time unit, but Camel offers milliseconds , and minutes as well. 100.16. Spring Boot Auto-Configuration The component supports 5 options, which are listed below. Name Description Default Type camel.component.mock.autowired-enabled Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc. true Boolean camel.component.mock.enabled Whether to enable auto configuration of the mock component. This is enabled by default. Boolean camel.component.mock.exchange-formatter Sets a custom ExchangeFormatter to convert the Exchange to a String suitable for logging. If not specified, we default to DefaultExchangeFormatter. The option is a org.apache.camel.spi.ExchangeFormatter type. ExchangeFormatter camel.component.mock.lazy-start-producer Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. false Boolean camel.component.mock.log To turn on logging when the mock receives an incoming message. This will log only one time at INFO level for the incoming message. For more detailed logging then set the logger to DEBUG level for the org.apache.camel.component.mock.MockEndpoint class. false Boolean	[ "<dependency> <groupId>org.apache.camel.springboot</groupId> <artifactId>camel-mock-starter</artifactId> </dependency>", "mock:someName[?options]", "mock:name", "MockEndpoint resultEndpoint = context.getEndpoint(\"mock:foo\", MockEndpoint.class); // set expectations resultEndpoint.expectedMessageCount(2); // send some messages // now lets assert that the mock:foo endpoint received 2 messages resultEndpoint.assertIsSatisfied();", "MockEndpoint resultEndpoint = context.getEndpoint(\"mock:foo\", MockEndpoint.class); resultEndpoint.setAssertPeriod(5000); resultEndpoint.expectedMessageCount(2); // send some messages // now lets assert that the mock:foo endpoint received 2 messages resultEndpoint.assertIsSatisfied();", "resultEndpoint.expectedBodiesReceived(\"firstMessageBody\", \"secondMessageBody\", \"thirdMessageBody\");", "resultEndpoint.message(0).header(\"foo\").isEqualTo(\"bar\");", "@Override protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { @Override public void configure() throws Exception { from(\"direct:start\").routeId(\"start\") .to(\"direct:foo\").to(\"log:foo\").to(\"mock:result\"); from(\"direct:foo\").routeId(\"foo\") .transform(constant(\"Bye World\")); } }; }", "@Test public void testAdvisedMockEndpoints() throws Exception { // advice the start route using the inlined AdviceWith lambda style route builder // which has extended capabilities than the regular route builder AdviceWith.adviceWith(context, \"start\", a -> // mock all endpoints a.mockEndpoints()); getMockEndpoint(\"mock:direct:start\").expectedBodiesReceived(\"Hello World\"); getMockEndpoint(\"mock:direct:foo\").expectedBodiesReceived(\"Hello World\"); getMockEndpoint(\"mock:log:foo\").expectedBodiesReceived(\"Bye World\"); getMockEndpoint(\"mock:result\").expectedBodiesReceived(\"Bye World\"); template.sendBody(\"direct:start\", \"Hello World\"); assertMockEndpointsSatisfied(); // additional test to ensure correct endpoints in registry assertNotNull(context.hasEndpoint(\"direct:start\")); assertNotNull(context.hasEndpoint(\"direct:foo\")); assertNotNull(context.hasEndpoint(\"log:foo\")); assertNotNull(context.hasEndpoint(\"mock:result\")); // all the endpoints was mocked assertNotNull(context.hasEndpoint(\"mock:direct:start\")); assertNotNull(context.hasEndpoint(\"mock:direct:foo\")); assertNotNull(context.hasEndpoint(\"mock:log:foo\")); }", "INFO Adviced endpoint [direct://foo] with mock endpoint [mock:direct:foo]", "@Test public void testAdvisedMockEndpointsWithPattern() throws Exception { // advice the start route using the inlined AdviceWith lambda style route builder // which has extended capabilities than the regular route builder AdviceWith.adviceWith(context, \"start\", a -> // mock only log endpoints a.mockEndpoints(\"log\")); // now we can refer to log:foo as a mock and set our expectations getMockEndpoint(\"mock:log:foo\").expectedBodiesReceived(\"Bye World\"); getMockEndpoint(\"mock:result\").expectedBodiesReceived(\"Bye World\"); template.sendBody(\"direct:start\", \"Hello World\"); assertMockEndpointsSatisfied(); // additional test to ensure correct endpoints in registry assertNotNull(context.hasEndpoint(\"direct:start\")); assertNotNull(context.hasEndpoint(\"direct:foo\")); assertNotNull(context.hasEndpoint(\"log:foo\")); assertNotNull(context.hasEndpoint(\"mock:result\")); // only the log:foo endpoint was mocked assertNotNull(context.hasEndpoint(\"mock:log:foo\")); assertNull(context.hasEndpoint(\"mock:direct:start\")); assertNull(context.hasEndpoint(\"mock:direct:foo\")); }", "public class IsMockEndpointsJUnit4Test extends CamelTestSupport { @Override public String isMockEndpoints() { // override this method and return the pattern for which endpoints to mock. // use to indicate all return \"\"; } @Test public void testMockAllEndpoints() throws Exception { // notice we have automatic mocked all endpoints and the name of the endpoints is \"mock:uri\" getMockEndpoint(\"mock:direct:start\").expectedBodiesReceived(\"Hello World\"); getMockEndpoint(\"mock:direct:foo\").expectedBodiesReceived(\"Hello World\"); getMockEndpoint(\"mock:log:foo\").expectedBodiesReceived(\"Bye World\"); getMockEndpoint(\"mock:result\").expectedBodiesReceived(\"Bye World\"); template.sendBody(\"direct:start\", \"Hello World\"); assertMockEndpointsSatisfied(); // additional test to ensure correct endpoints in registry assertNotNull(context.hasEndpoint(\"direct:start\")); assertNotNull(context.hasEndpoint(\"direct:foo\")); assertNotNull(context.hasEndpoint(\"log:foo\")); assertNotNull(context.hasEndpoint(\"mock:result\")); // all the endpoints was mocked assertNotNull(context.hasEndpoint(\"mock:direct:start\")); assertNotNull(context.hasEndpoint(\"mock:direct:foo\")); assertNotNull(context.hasEndpoint(\"mock:log:foo\")); } @Override protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { @Override public void configure() throws Exception { from(\"direct:start\").to(\"direct:foo\").to(\"log:foo\").to(\"mock:result\"); from(\"direct:foo\").transform(constant(\"Bye World\")); } }; } }", "<!-- this camel route is in the camel-route.xml file --> <camelContext xmlns=\"http://camel.apache.org/schema/spring\"> <route> <from uri=\"direct:start\"/> <to uri=\"direct:foo\"/> <to uri=\"log:foo\"/> <to uri=\"mock:result\"/> </route> <route> <from uri=\"direct:foo\"/> <transform> <constant>Bye World</constant> </transform> </route> </camelContext>", "<!-- the Camel route is defined in another XML file --> <import resource=\"camel-route.xml\"/> <!-- bean which enables mocking all endpoints --> <bean id=\"mockAllEndpoints\" class=\"org.apache.camel.component.mock.InterceptSendToMockEndpointStrategy\"/>", "<bean id=\"mockAllEndpoints\" class=\"org.apache.camel.impl.InterceptSendToMockEndpointStrategy\"> <constructor-arg index=\"0\" value=\"log\"/> </bean>", "@Test public void testAdvisedMockEndpointsWithSkip() throws Exception { // advice the first route using the inlined AdviceWith route builder // which has extended capabilities than the regular route builder AdviceWith.adviceWith(context.getRouteDefinitions().get(0), context, new AdviceWithRouteBuilder() { @Override public void configure() throws Exception { // mock sending to direct:foo and direct:bar and skip send to it mockEndpointsAndSkip(\"direct:foo\", \"direct:bar\"); } }); getMockEndpoint(\"mock:result\").expectedBodiesReceived(\"Hello World\"); getMockEndpoint(\"mock:direct:foo\").expectedMessageCount(1); getMockEndpoint(\"mock:direct:bar\").expectedMessageCount(1); template.sendBody(\"direct:start\", \"Hello World\"); assertMockEndpointsSatisfied(); // the message was not send to the direct:foo route and thus not sent to // the seda endpoint SedaEndpoint seda = context.getEndpoint(\"seda:foo\", SedaEndpoint.class); assertEquals(0, seda.getCurrentQueueSize()); }", "public class IsMockEndpointsAndSkipJUnit4Test extends CamelTestSupport { @Override public String isMockEndpointsAndSkip() { // override this method and return the pattern for which endpoints to mock, // and skip sending to the original endpoint. return \"direct:foo\"; } @Test public void testMockEndpointAndSkip() throws Exception { // notice we have automatic mocked the direct:foo endpoints and the name of the endpoints is \"mock:uri\" getMockEndpoint(\"mock:result\").expectedBodiesReceived(\"Hello World\"); getMockEndpoint(\"mock:direct:foo\").expectedMessageCount(1); template.sendBody(\"direct:start\", \"Hello World\"); assertMockEndpointsSatisfied(); // the message was not send to the direct:foo route and thus not sent to the seda endpoint SedaEndpoint seda = context.getEndpoint(\"seda:foo\", SedaEndpoint.class); assertEquals(0, seda.getCurrentQueueSize()); } @Override protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { @Override public void configure() throws Exception { from(\"direct:start\").to(\"direct:foo\").to(\"mock:result\"); from(\"direct:foo\").transform(constant(\"Bye World\")).to(\"seda:foo\"); } }; } }", "MockEndpoint mock = getMockEndpoint(\"mock:data\"); mock.setRetainFirst(5); mock.setRetainLast(5); mock.expectedMessageCount(2000); mock.assertIsSatisfied();", "Date time = exchange.getProperty(Exchange.RECEIVED_TIMESTAMP, Date.class);", "mock.message(0).arrives().noLaterThan(2).seconds().beforeNext();", "mock.message(1).arrives().noLaterThan(2).seconds().afterPrevious();", "mock.message(1).arrives().between(1, 4).seconds().afterPrevious();", "mock.allMessages().arrives().noLaterThan(1).seconds().beforeNext();" ]	https://docs.redhat.com/en/documentation/red_hat_build_of_apache_camel/4.8/html/red_hat_build_of_apache_camel_for_spring_boot_reference/csb-camel-mock-component-starter
Chapter 57. File Systems	Chapter 57. File Systems NetApp storage appliances serving NFSv4 are advised to check their configuration Note that features can be enabled or disabled on a per-minor version basis when using NetApp storage appliances that serve NFSv4. It is recommended to verify the configuration to ensure that the appropriate features are enabled as desired, for example by using the following Data ONTAP command: (BZ# 1450447 )	[ "vserver nfs show -vserver <vserver-name> -fields v4.0-acl,v4.0-read-delegation,v4.0-write-delegation,v4.0-referrals,v4.0-migration,v4.1-referrals,v4.1-migration,v4.1-acl,v4.1-read-delegation,v4.1-write-delegation" ]	https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/7/html/7.4_release_notes/known_issues_file_systems
function::user_long	function::user_long Name function::user_long - Retrieves a long value stored in user space. Synopsis Arguments addr The user space address to retrieve the long from. General Syntax user_long:long(addr:long) Description Returns the long value from a given user space address. Returns zero when user space data is not accessible. Note that the size of the long depends on the architecture of the current user space task (for those architectures that support both 64/32 bit compat tasks).	[ "function user_long:long(addr:long)" ]	https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/6/html/systemtap_tapset_reference/api-user-long
Chapter 4. Security and Authentication of HawtIO	Chapter 4. Security and Authentication of HawtIO HawtIO enables authentication out of the box depending on the runtimes/containers it runs with. To use HawtIO with your application, either setting up authentication for the runtime or disabling HawtIO authentication is necessary. 4.1. Configuration properties The following table lists the Security-related configuration properties for the HawtIO core system. Name Default Description hawtio.authenticationContainerDiscoveryClasses io.hawt.web.tomcat.TomcatAuthenticationContainerDiscovery List of used AuthenticationContainerDiscovery implementations separated by a comma. By default, there is just TomcatAuthenticationContainerDiscovery, which is used to authenticate users on Tomcat from tomcat-users.xml file. Feel free to remove it if you want to authenticate users on Tomcat from the configured JAAS login module or feel free to add more classes of your own. hawtio.authenticationContainerTomcatDigestAlgorithm NONE When using the Tomcat tomcat-users.xml file, passwords can be hashed instead of plain text. Use this to specify the digest algorithm; valid values are NONE, MD5, SHA, SHA-256, SHA-384, and SHA-512. hawtio.authenticationEnabled true Whether or not security is enabled. hawtio.keycloakClientConfig classpath:keycloak.json Keycloak configuration file used for the front end. It is mandatory if Keycloak integration is enabled. hawtio.keycloakEnabled false Whether to enable or disable Keycloak integration. hawtio.noCredentials401 false Whether to return HTTP status 401 when authentication is enabled, but no credentials have been provided. Returning 401 will cause the browser popup window to prompt for credentials. By default this option is false, returning HTTP status 403 instead. hawtio.realm hawtio The security realm used to log in. hawtio.rolePrincipalClasses Fully qualified principal class name(s). A comma can separate multiple classes. hawtio.roles Admin, manager, viewer The user roles are required to log in to the console. A comma can separate multiple roles to allow. Set to * or an empty value to disable role checking when HawtIO authenticates a user. hawtio.tomcatUserFileLocation conf/tomcat-users.xml Specify an alternative location for the tomcat-users.xml file, e.g. /production/userlocation/. 4.2. Quarkus HawtIO is secured with the authentication mechanisms that Quarkus and also Keycloak provide. If you want to disable HawtIO authentication for Quarkus, add the following configuration to application.properties : quarkus.hawtio.authenticationEnabled = false 4.2.1. Quarkus authentication mechanisms HawtIO is just a web application in terms of Quarkus, so the various mechanisms Quarkus provides are used to authenticate HawtIO in the same way it authenticates a Web application. Here we show how you can use the properties-based authentication with HawtIO for demonstrating purposes. Important The properties-based authentication is not recommended for use in production. This mechanism is for development and testing purposes only. To use the properties-based authentication with HawtIO, add the following dependency to pom.xml : <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-elytron-security-properties-file</artifactId> </dependency> You can then define users in application.properties to enable the authentication. For example, defining a user hawtio with password s3cr3t! and role admin would look like the following: quarkus.security.users.embedded.enabled = true quarkus.security.users.embedded.plain-text = true quarkus.security.users.embedded.users.hawtio = s3cr3t! quarkus.security.users.embedded.roles.hawtio = admin Example: See Quarkus example for a working example of the properties-based authentication. 4.2.2. Quarkus with Keycloak See Keycloak Integration - Quarkus . 4.3. Spring Boot In addition to the standard JAAS authentication, HawtIO on Spring Boot can be secured through Spring Security or Keycloak . If you want to disable HawtIO authentication for Spring Boot, add the following configuration to application.properties : hawtio.authenticationEnabled = false 4.3.1. Spring Security To use Spring Security with HawtIO: Add org.springframework.boot:spring-boot-starter-security to the dependencies in pom.xml : <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> Spring Security configuration in src/main/resources/application.properties should look like the following: spring.security.user.name = hawtio spring.security.user.password = s3cr3t! spring.security.user.roles = admin,viewer A security config class has to be defined to set up how to secure the application with Spring Security: @EnableWebSecurity public class SecurityConfig { @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http.authorizeRequests().anyRequest().authenticated() .and() .formLogin() .and() .httpBasic() .and() .csrf().csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse()); return http.build(); } } Example: See springboot-security example for a working example. 4.3.1.1. Connecting to a remote application with Spring Security If you try to connect to a remote Spring Boot application with Spring Security enabled, make sure the Spring Security configuration allows access from the HawtIO console. Most likely, the default CSRF protection prohibits remote access to the Jolokia endpoint and thus causes authentication failures at the HawtIO console. Warning Be aware that it will expose your application to the risk of CSRF attacks. The easiest solution is to disable CSRF protection for the Jolokia endpoint at the remote application as follows. import org.springframework.boot.actuate.autoconfigure.jolokia.JolokiaEndpoint; import org.springframework.boot.actuate.autoconfigure.security.servlet.EndpointRequest; @EnableWebSecurity public class SecurityConfig { @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { ... // Disable CSRF protection for the Jolokia endpoint http.csrf().ignoringRequestMatchers(EndpointRequest.to(JolokiaEndpoint.class)); return http.build(); } } To secure the Jolokia endpoint even without Spring Security's CSRF protection, you need to provide a jolokia-access.xml file under src/main/resources/ like the following (snippet) so that only trusted nodes can access it: <restrict> ... <cors> <allow-origin>http://localhost:</allow-origin> <allow-origin>http://127.0.0.1:</allow-origin> <allow-origin>http://.example.com</allow-origin> <allow-origin>http://.example.com:*</allow-origin> <strict-checking /> </cors> </restrict> 4.3.2. Spring Boot with Keycloak See Keycloak Integration - Spring Boot .	[ "quarkus.hawtio.authenticationEnabled = false", "<dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-elytron-security-properties-file</artifactId> </dependency>", "quarkus.security.users.embedded.enabled = true quarkus.security.users.embedded.plain-text = true quarkus.security.users.embedded.users.hawtio = s3cr3t! quarkus.security.users.embedded.roles.hawtio = admin", "hawtio.authenticationEnabled = false", "<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency>", "spring.security.user.name = hawtio spring.security.user.password = s3cr3t! spring.security.user.roles = admin,viewer", "@EnableWebSecurity public class SecurityConfig { @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http.authorizeRequests().anyRequest().authenticated() .and() .formLogin() .and() .httpBasic() .and() .csrf().csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse()); return http.build(); } }", "import org.springframework.boot.actuate.autoconfigure.jolokia.JolokiaEndpoint; import org.springframework.boot.actuate.autoconfigure.security.servlet.EndpointRequest; @EnableWebSecurity public class SecurityConfig { @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { // Disable CSRF protection for the Jolokia endpoint http.csrf().ignoringRequestMatchers(EndpointRequest.to(JolokiaEndpoint.class)); return http.build(); } }", "<restrict> <cors> <allow-origin>http://localhost:</allow-origin> <allow-origin>http://127.0.0.1:</allow-origin> <allow-origin>http://.example.com</allow-origin> <allow-origin>http://.example.com:*</allow-origin> <strict-checking /> </cors> </restrict>" ]	https://docs.redhat.com/en/documentation/red_hat_build_of_apache_camel/4.0/html/hawtio_diagnostic_console_guide/security-and-authentication-of-hawtio
Chapter 6. AWS Lambda Sink	Chapter 6. AWS Lambda Sink Send a payload to an AWS Lambda function 6.1. Configuration Options The following table summarizes the configuration options available for the aws-lambda-sink Kamelet: Property Name Description Type Default Example accessKey * Access Key The access key obtained from AWS string function * Function Name The Lambda Function name string region * AWS Region The AWS region to connect to string "eu-west-1" secretKey * Secret Key The secret key obtained from AWS string Note Fields marked with an asterisk (*) are mandatory. 6.2. Dependencies At runtime, the aws-lambda-sink Kamelet relies upon the presence of the following dependencies: camel:kamelet camel:aws2-lambda 6.3. Usage This section describes how you can use the aws-lambda-sink . 6.3.1. Knative Sink You can use the aws-lambda-sink Kamelet as a Knative sink by binding it to a Knative object. aws-lambda-sink-binding.yaml apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: aws-lambda-sink-binding spec: source: ref: kind: Channel apiVersion: messaging.knative.dev/v1 name: mychannel sink: ref: kind: Kamelet apiVersion: camel.apache.org/v1alpha1 name: aws-lambda-sink properties: accessKey: "The Access Key" function: "The Function Name" region: "eu-west-1" secretKey: "The Secret Key" 6.3.1.1. Prerequisite Make sure you have "Red Hat Integration - Camel K" installed into the OpenShift cluster you're connected to. 6.3.1.2. Procedure for using the cluster CLI Save the aws-lambda-sink-binding.yaml file to your local drive, and then edit it as needed for your configuration. Run the sink by using the following command: oc apply -f aws-lambda-sink-binding.yaml 6.3.1.3. Procedure for using the Kamel CLI Configure and run the sink by using the following command: kamel bind channel:mychannel aws-lambda-sink -p "sink.accessKey=The Access Key" -p "sink.function=The Function Name" -p "sink.region=eu-west-1" -p "sink.secretKey=The Secret Key" This command creates the KameletBinding in the current namespace on the cluster. 6.3.2. Kafka Sink You can use the aws-lambda-sink Kamelet as a Kafka sink by binding it to a Kafka topic. aws-lambda-sink-binding.yaml apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: aws-lambda-sink-binding spec: source: ref: kind: KafkaTopic apiVersion: kafka.strimzi.io/v1beta1 name: my-topic sink: ref: kind: Kamelet apiVersion: camel.apache.org/v1alpha1 name: aws-lambda-sink properties: accessKey: "The Access Key" function: "The Function Name" region: "eu-west-1" secretKey: "The Secret Key" 6.3.2.1. Prerequisites Ensure that you've installed the AMQ Streams operator in your OpenShift cluster and created a topic named my-topic in the current namespace. Make also sure you have "Red Hat Integration - Camel K" installed into the OpenShift cluster you're connected to. 6.3.2.2. Procedure for using the cluster CLI Save the aws-lambda-sink-binding.yaml file to your local drive, and then edit it as needed for your configuration. Run the sink by using the following command: oc apply -f aws-lambda-sink-binding.yaml 6.3.2.3. Procedure for using the Kamel CLI Configure and run the sink by using the following command: kamel bind kafka.strimzi.io/v1beta1:KafkaTopic:my-topic aws-lambda-sink -p "sink.accessKey=The Access Key" -p "sink.function=The Function Name" -p "sink.region=eu-west-1" -p "sink.secretKey=The Secret Key" This command creates the KameletBinding in the current namespace on the cluster. 6.4. Kamelet source file https://github.com/openshift-integration/kamelet-catalog/aws-lambda-sink.kamelet.yaml	[ "apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: aws-lambda-sink-binding spec: source: ref: kind: Channel apiVersion: messaging.knative.dev/v1 name: mychannel sink: ref: kind: Kamelet apiVersion: camel.apache.org/v1alpha1 name: aws-lambda-sink properties: accessKey: \"The Access Key\" function: \"The Function Name\" region: \"eu-west-1\" secretKey: \"The Secret Key\"", "apply -f aws-lambda-sink-binding.yaml", "kamel bind channel:mychannel aws-lambda-sink -p \"sink.accessKey=The Access Key\" -p \"sink.function=The Function Name\" -p \"sink.region=eu-west-1\" -p \"sink.secretKey=The Secret Key\"", "apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: aws-lambda-sink-binding spec: source: ref: kind: KafkaTopic apiVersion: kafka.strimzi.io/v1beta1 name: my-topic sink: ref: kind: Kamelet apiVersion: camel.apache.org/v1alpha1 name: aws-lambda-sink properties: accessKey: \"The Access Key\" function: \"The Function Name\" region: \"eu-west-1\" secretKey: \"The Secret Key\"", "apply -f aws-lambda-sink-binding.yaml", "kamel bind kafka.strimzi.io/v1beta1:KafkaTopic:my-topic aws-lambda-sink -p \"sink.accessKey=The Access Key\" -p \"sink.function=The Function Name\" -p \"sink.region=eu-west-1\" -p \"sink.secretKey=The Secret Key\"" ]	https://docs.redhat.com/en/documentation/red_hat_build_of_apache_camel_k/1.10.9/html/kamelets_reference/aws-lambda-sink
19.6.3. Related Books	19.6.3. Related Books Sendmail Milters: A Guide for Fighting Spam by Bryan Costales and Marcia Flynt; Addison-Wesley - A good Sendmail guide that can help you customize your mail filters. Sendmail by Bryan Costales with Eric Allman et al.; O'Reilly & Associates - A good Sendmail reference written with the assistance of the original creator of Delivermail and Sendmail. Removing the Spam: Email Processing and Filtering by Geoff Mulligan; Addison-Wesley Publishing Company - A volume that looks at various methods used by email administrators using established tools, such as Sendmail and Procmail, to manage spam problems. Internet Email Protocols: A Developer's Guide by Kevin Johnson; Addison-Wesley Publishing Company - Provides a very thorough review of major email protocols and the security they provide. Managing IMAP by Dianna Mullet and Kevin Mullet; O'Reilly & Associates - Details the steps required to configure an IMAP server.	null	https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/6/html/deployment_guide/s2-email-related-books
3.4. Discovering and Joining Identity Domains	3.4. Discovering and Joining Identity Domains The realm discover command returns complete domain configuration and a list of packages that must be installed for the system to be enrolled in the domain. The realm join command then sets up the local machine for use with a specified domain by configuring both the local system services and the entries in the identity domain. The process run by realm join follows these steps: Running a discovery scan for the specified domain. Automatic installation of the packages required to join the system to the domain. This includes SSSD and the PAM home directory job packages. Note that the automatic installation of packages requires the PackageKit suite to be running. Note If PackageKit is disabled, the system prompts you for the missing packages, and you will be required to install them manually using the yum utility. Joining the domain by creating an account entry for the system in the directory. Creating the /etc/krb5.keytab host keytab file. Configuring the domain in SSSD and restarting the service. Enabling domain users for the system services in PAM configuration and the /etc/nsswitch.conf file. Discovering Domains When run without any options, the realm discover command displays information about the default DNS domain, which is the domain assigned through the Dynamic Host Configuration Protocol (DHCP): It is also possible to run a discovery for a specific domain. To do this, run realm discover and add the name of the domain you want to discover: The realmd system will then use DNS SRV lookups to find the domain controllers in this domain automatically. Note The realm discover command requires NetworkManager to be running; in particular, it depends on the D-Bus interface of NetworkManager. If your system does not use NetworkManager, always specify the domain name in the realm discover command. The realmd system can discover both Active Directory and Identity Management domains. If both domains exist in your environment, you can limit the discovery results to a specific type of server using the --server-software option. For example: One of the attributes returned in the discovery search is login-policy , which shows if domain users are allowed to log in as soon as the join is complete. If logins are not allowed by default, you can allow them manually by using the realm permit command. For details, see Section 3.7, "Managing Login Permissions for Domain Users" . For more information about the realm discover command, see the realm (8) man page. Joining a Domain Important Note that Active Directory domains require unique computer names to be used. Both NetBIOS computer name and its DNS host name should be uniquely defined and correspond to each other. To join the system to an identity domain, use the realm join command and specify the domain name: By default, the join is performed as the domain administrator. For AD, the administrator account is called Administrator ; for IdM, it is called admin . To connect as a different user, use the -U option: The command first attempts to connect without credentials, but it prompts for a password if required. If Kerberos is properly configured on a Linux system, joining can also be performed with a Kerberos ticket for authentication. To select a Kerberos principal, use the -U option. The realm join command accepts several other configuration options. For more information about the realm join command, see the realm (8) man page. Example 3.1. Example Procedure for Enrolling a System into a Domain Run the realm discover command to display information about the domain. Run the realm join command and pass the domain name to the command. Provide the administrator password if the system prompts for it. Note that when discovering or joining a domain, realmd checks for the DNS SRV record: _ldap._tcp.domain.example.com. for Identity Management records _ldap._tcp.dc._msdcs.domain.example.com. for Active Directory records The record is created by default when AD is configured, which enables it to be found by the service discovery. Testing the System Configuration after Joining a Domain To test whether the system was successfully enrolled into a domain, verify that you can log in as a user from the domain and that the user information is displayed correctly: Run the id user @ domain_name command to display information about a user from the domain. Using the ssh utility, log in as the same user. Verify that the pwd utility prints the user's home directory. Verify that the id utility prints the same information as the id user @ domain_name command from the first step. The kinit utility is also useful when testing whether the domain join was successful. Note that to use the utility, the krb5-workstation package must be installed.	[ "realm discover ad.example.com type: kerberos realm-name: AD.EXAMPLE.COM domain-name: ad.example.com configured: no server-software: active-directory client-software: sssd required-package: oddjob required-package: oddjob-mkhomedir required-package: sssd required-package: adcli required-package: samba-common", "realm discover ad.example.com", "realm discover --server-software=active-directory", "realm join ad.example.com realm: Joined ad.example.com domain", "realm join ad.example.com -U user", "kinit user # realm join ad.example.com -U user", "realm discover ad.example.com ad.example.com type: kerberos realm-name: AD.EXAMPLE.COM domain-name: ad.example.com configured: no server-software: active-directory client-software: sssd", "realm join ad.example.com Password for Administrator: password", "id user @ ad.example.com uid=1348601103([email protected]) gid=1348600513(domain [email protected]) groups=1348600513(domain [email protected])", "ssh -l user @ ad.example.com linux-client.ad.example.com [email protected]@linux-client.ad.example.com's password: Creating home directory for [email protected].", "pwd /home/ad.example.com/user", "id uid=1348601103([email protected]) gid=1348600513(domain [email protected]) groups=1348600513(domain [email protected]) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023" ]	https://docs.redhat.com/en/documentation/Red_Hat_Enterprise_Linux/7/html/windows_integration_guide/realmd-domain
7.57. gcc	7.57. gcc 7.57.1. RHBA-2015:1339 - gcc bug fix and enhancement update Updated gcc packages that fix several bugs and add one enhancement are now available for Red Hat Enterprise Linux 6. The gcc packages provide compilers for C, C++, Java, Fortran, Objective C, and Ada 95 GNU, as well as related support libraries. Bug Fixes BZ# 1190640 Previously, due to a bug in the stdarg functions optimization, the compiler could produce incorrect code. The problem occurred only when the va_list variable escaped a PHI node. This bug has been fixed, and the compiler now generates correct code. BZ# 1150606 Previously, when the vectorization optimization was enabled, the compiler could extract a scalar component of a vector with element types whose precision did not match the precision of their mode. Consequently, GCC could terminate unexpectedly while trying to vectorize a code that was using bit-fields. With this update, the compiler no longer vectorizes such code, and the code now compiles correctly. BZ# 1177458 Previously, the compiler did not properly handle incorrect usage of the PCH (Precompiled Headers) feature. When a PCH file was not included as the first include, the compiler terminated unexpectedly with a segmentation fault. The compiler has been fixed not to use such incorrect includes, and it no longer crashes in this scenario. BZ# 1134560 In versions of the GNU Fortran compiler, the type specifiers for Cray pointees were incorrectly overwritten by the type specifiers of components with the same name. Consequently, compiling failed with an error message. This bug has been fixed, and the Cray pointers are now handled correctly. Enhancement BZ# 1148120 The gcc hotpatch attribute implements support for online patching of multithreaded code on System z binaries. With this update, it is possible to select specific functions for hotpatching using a "function attribute" and to enable hotpatching for all functions using the "-mhotpatch=" command-line option. As enabled hotpatching has negative impact on software size and performance, it is recommended to use hotpatching for specific functions and not to enable hotpatch support in general. Users of gcc are advised to upgrade to these updated packages, which fix these bugs and add this enhancement.	null	https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/6/html/6.7_technical_notes/package-gcc
Chapter 2. Installing Red Hat Developer Hub in an air-gapped environment with the Operator	Chapter 2. Installing Red Hat Developer Hub in an air-gapped environment with the Operator On an OpenShift Container Platform cluster operating on a restricted network, public resources are not available. However, deploying the Red Hat Developer Hub Operator and running Developer Hub requires the following public resources: Operator images (bundle, operator, catalog) Operands images (RHDH, PostgreSQL) To make these resources available, replace them with their equivalent resources in a mirror registry accessible to the OpenShift Container Platform cluster. You can use a helper script that mirrors the necessary images and provides the necessary configuration to ensure those images will be used when installing the Red Hat Developer Hub Operator and creating Developer Hub instances. Note This script requires a target mirror registry which you should already have installed if your OpenShift Container Platform cluster is ready to operate on a restricted network. However, if you are preparing your cluster for disconnected usage, you can use the script to deploy a mirror registry in the cluster and use it for the mirroring process. Prerequisites You have an active OpenShift CLI ( oc ) session with administrative permissions to the OpenShift Container Platform cluster. See Getting started with the OpenShift CLI . You have an active oc registry session to the registry.redhat.io Red Hat Ecosystem Catalog. See Red Hat Container Registry Authentication . The opm CLI tool is installed. See Installing the opm CLI . The jq package is installed. See Download jq . Podman is installed. See Podman Installation Instructions . Skopeo version 1.14 or higher is installed. See Installing Skopeo . If you already have a mirror registry for your cluster, an active Skopeo session with administrative access to this registry is required. See Authenticating to a registry and Mirroring images for a disconnected installation . Note The internal OpenShift Container Platform cluster image registry cannot be used as a target mirror registry. See About the mirror registry . If you prefer to create your own mirror registry, see Creating a mirror registry with mirror registry for Red Hat OpenShift . If you do not already have a mirror registry, you can use the helper script to create one for you and you need the following additional prerequisites: The cURL package is installed. For Red Hat Enterprise Linux, the curl command is available by installing the curl package. To use curl for other platforms, see the cURL website . The htpasswd command is available. For Red Hat Enterprise Linux, the htpasswd command is available by installing the httpd-tools package. Procedure Download and run the mirroring script to install a custom Operator catalog and mirror the related images: prepare-restricted-environment.sh ( source ). curl -sSLO https://raw.githubusercontent.com/redhat-developer/rhdh-operator/release-1.3/.rhdh/scripts/prepare-restricted-environment.sh # if you do not already have a target mirror registry # and want the script to create one for you # use the following example: bash prepare-restricted-environment.sh \ --prod_operator_index "registry.redhat.io/redhat/redhat-operator-index:v4.17" \ --prod_operator_package_name "rhdh" \ --prod_operator_bundle_name "rhdh-operator" \ --prod_operator_version "v1.3.5" # if you already have a target mirror registry # use the following example: bash prepare-restricted-environment.sh \ --prod_operator_index "registry.redhat.io/redhat/redhat-operator-index:v4.17" \ --prod_operator_package_name "rhdh" \ --prod_operator_bundle_name "rhdh-operator" \ --prod_operator_version "v1.3.5" \ --use_existing_mirror_registry "my_registry" Note The script can take several minutes to complete as it copies multiple images to the mirror registry.	[ "curl -sSLO https://raw.githubusercontent.com/redhat-developer/rhdh-operator/release-1.3/.rhdh/scripts/prepare-restricted-environment.sh if you do not already have a target mirror registry and want the script to create one for you use the following example: bash prepare-restricted-environment.sh --prod_operator_index \"registry.redhat.io/redhat/redhat-operator-index:v4.17\" --prod_operator_package_name \"rhdh\" --prod_operator_bundle_name \"rhdh-operator\" --prod_operator_version \"v1.3.5\" if you already have a target mirror registry use the following example: bash prepare-restricted-environment.sh --prod_operator_index \"registry.redhat.io/redhat/redhat-operator-index:v4.17\" --prod_operator_package_name \"rhdh\" --prod_operator_bundle_name \"rhdh-operator\" --prod_operator_version \"v1.3.5\" --use_existing_mirror_registry \"my_registry\"" ]	https://docs.redhat.com/en/documentation/red_hat_developer_hub/1.3/html/installing_red_hat_developer_hub_in_an_air-gapped_environment/proc-install-rhdh-airgapped-environment-ocp-operator_title-install-rhdh-air-grapped
24.5.4. Using the lscpu Command	24.5.4. Using the lscpu Command The lscpu command allows you to list information about CPUs that are present in the system, including the number of CPUs, their architecture, vendor, family, model, CPU caches, etc. To do so, type the following at a shell prompt: lscpu For example: For a complete list of available command-line options, see the lscpu (1) manual page.	[ "~]USD lscpu Architecture: x86_64 CPU op-mode(s): 32-bit, 64-bit Byte Order: Little Endian CPU(s): 4 On-line CPU(s) list: 0-3 Thread(s) per core: 1 Core(s) per socket: 4 Socket(s): 1 NUMA node(s): 1 Vendor ID: GenuineIntel CPU family: 6 Model: 23 Stepping: 7 CPU MHz: 1998.000 BogoMIPS: 4999.98 Virtualization: VT-x L1d cache: 32K L1i cache: 32K L2 cache: 3072K NUMA node0 CPU(s): 0-3" ]	https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/6/html/deployment_guide/s2-sysinfo-hardware-lscpu
Chapter 4. Red Hat OpenShift Cluster Manager	Chapter 4. Red Hat OpenShift Cluster Manager Red Hat OpenShift Cluster Manager is a managed service where you can install, modify, operate, and upgrade your Red Hat OpenShift clusters. This service allows you to work with all of your organization's clusters from a single dashboard. OpenShift Cluster Manager guides you to install OpenShift Container Platform, Red Hat OpenShift Service on AWS (ROSA), and OpenShift Dedicated clusters. It is also responsible for managing both OpenShift Container Platform clusters after self-installation as well as your ROSA and OpenShift Dedicated clusters. You can use OpenShift Cluster Manager to do the following actions: Create new clusters View cluster details and metrics Manage your clusters with tasks such as scaling, changing node labels, networking, authentication Manage access control Monitor clusters Schedule upgrades 4.1. Accessing Red Hat OpenShift Cluster Manager You can access OpenShift Cluster Manager with your configured OpenShift account. Prerequisites You have an account that is part of an OpenShift organization. If you are creating a cluster, your organization has specified quota. Procedure Log in to OpenShift Cluster Manager using your login credentials. 4.2. General actions On the top right of the cluster page, there are some actions that a user can perform on the entire cluster: Open console launches a web console so that the cluster owner can issue commands to the cluster. Actions drop-down menu allows the cluster owner to rename the display name of the cluster, change the amount of load balancers and persistent storage on the cluster, if applicable, manually set the node count, and delete the cluster. Refresh icon forces a refresh of the cluster. 4.3. Cluster tabs Selecting an active, installed cluster shows tabs associated with that cluster. The following tabs display after the cluster's installation completes: Overview Access control Add-ons Networking Insights Advisor Machine pools Support Settings 4.3.1. Overview tab The Overview tab provides information about how your cluster was configured: Cluster ID is the unique identification for the created cluster. This ID can be used when issuing commands to the cluster from the command line. Type shows the OpenShift version that the cluster is using. Region is the server region. Provider shows which cloud provider that the cluster was built upon. Availability shows which type of availability zone that the cluster uses, either single or multizone. Version is the OpenShift version that is installed on the cluster. If there is an update available, you can update from this field. Created at shows the date and time that the cluster was created. Owner identifies who created the cluster and has owner rights. Subscription type shows the subscription model that was selected on creation. Infrastructure type is the type of account that the cluster uses. Status displays the current status of the cluster. Total vCPU shows the total available virtual CPU for this cluster. Total memory shows the total available memory for this cluster. Load balancers Persistent storage displays the amount of storage that is available on this cluster. Nodes shows the actual and desired nodes on the cluster. These numbers might not match due to cluster scaling. Network field shows the address and prefixes for network connectivity. Resource usage section of the tab displays the resources in use with a graph. Advisor recommendations section gives insight in relation to security, performance, availability, and stability. This section requires the use of remote health functionality. See Using Insights to identify issues with your cluster in the Additional resources section. Cluster history section shows everything that has been done with the cluster including creation and when a new version is identified. 4.3.2. Access control tab The Access control tab allows the cluster owner to set up an identity provider, grant elevated permissions, and grant roles to other users. Prerequisites You must be the cluster owner or have the correct permissions to grant roles on the cluster. Procedure Select the Grant role button. Enter the Red Hat account login for the user that you wish to grant a role on the cluster. Select the Grant role button on the dialog box. The dialog box closes, and the selected user shows the "Cluster Editor" access. 4.3.3. Add-ons tab The Add-ons tab displays all of the optional add-ons that can be added to the cluster. Select the desired add-on, and then select Install below the description for the add-on that displays. 4.3.4. Insights Advisor tab The Insights Advisor tab uses the Remote Health functionality of the OpenShift Container Platform to identify and mitigate risks to security, performance, availability, and stability. See Using Insights to identify issues with your cluster in the OpenShift Container Platform documentation. 4.3.5. Machine pools tab The Machine pools tab allows the cluster owner to create new machine pools, if there is enough available quota, or edit an existing machine pool. Selecting the More options > Scale opens the "Edit node count" dialog. In this dialog, you can change the node count per availability zone. If autoscaling is enabled, you can also set the range for autoscaling. 4.3.6. Support tab In the Support tab, you can add notification contacts for individuals that should receive cluster notifications. The username or email address that you provide must relate to a user account in the Red Hat organization where the cluster is deployed. Also from this tab, you can open a support case to request technical support for your cluster. 4.3.7. Settings tab The Settings tab provides a few options for the cluster owner: Monitoring , which is enabled by default, allows for reporting done on user-defined actions. See Understanding the monitoring stack . Update strategy allows you to determine if the cluster automatically updates on a certain day of the week at a specified time or if all updates are scheduled manually. Node draining sets the duration that protected workloads are respected during updates. When this duration has passed, the node is forcibly removed. Update status shows the current version and if there are any updates available. 4.4. Additional resources For the complete documentation for OpenShift Cluster Manager, see OpenShift Cluster Manager documentation .	null	https://docs.redhat.com/en/documentation/openshift_container_platform/4.16/html/architecture/ocm-overview-ocp
2.3. keepalived Scheduling Overview	2.3. keepalived Scheduling Overview Using Keepalived provides a great deal of flexibility in distributing traffic across real servers, in part due to the variety of scheduling algorithms supported. Load balancing is superior to less flexible methods, such as Round-Robin DNS where the hierarchical nature of DNS and the caching by client machines can lead to load imbalances. Additionally, the low-level filtering employed by the LVS router has advantages over application-level request forwarding because balancing loads at the network packet level causes minimal computational overhead and allows for greater scalability. Using assigned weights gives arbitrary priorities to individual machines. Using this form of scheduling, it is possible to create a group of real servers using a variety of hardware and software combinations and the active router can evenly load each real server. The scheduling mechanism for Keepalived is provided by a collection of kernel patches called IP Virtual Server or IPVS modules. These modules enable layer 4 ( L4 ) transport layer switching, which is designed to work well with multiple servers on a single IP address. To track and route packets to the real servers efficiently, IPVS builds an IPVS table in the kernel. This table is used by the active LVS router to redirect requests from a virtual server address to and returning from real servers in the pool. 2.3.1. Keepalived Scheduling Algorithms The structure that the IPVS table takes depends on the scheduling algorithm that the administrator chooses for any given virtual server. To allow for maximum flexibility in the types of services you can cluster and how these services are scheduled, Keepalived supports the following scheduling algorithms listed below. Round-Robin Scheduling Distributes each request sequentially around the pool of real servers. Using this algorithm, all the real servers are treated as equals without regard to capacity or load. This scheduling model resembles round-robin DNS but is more granular due to the fact that it is network-connection based and not host-based. Load Balancer round-robin scheduling also does not suffer the imbalances caused by cached DNS queries. Weighted Round-Robin Scheduling Distributes each request sequentially around the pool of real servers but gives more jobs to servers with greater capacity. Capacity is indicated by a user-assigned weight factor, which is then adjusted upward or downward by dynamic load information. Weighted round-robin scheduling is a preferred choice if there are significant differences in the capacity of real servers in the pool. However, if the request load varies dramatically, the more heavily weighted server may answer more than its share of requests. Least-Connection Distributes more requests to real servers with fewer active connections. Because it keeps track of live connections to the real servers through the IPVS table, least-connection is a type of dynamic scheduling algorithm, making it a better choice if there is a high degree of variation in the request load. It is best suited for a real server pool where each member node has roughly the same capacity. If a group of servers have different capabilities, weighted least-connection scheduling is a better choice. Weighted Least-Connections Distributes more requests to servers with fewer active connections relative to their capacities. Capacity is indicated by a user-assigned weight, which is then adjusted upward or downward by dynamic load information. The addition of weighting makes this algorithm ideal when the real server pool contains hardware of varying capacity. Locality-Based Least-Connection Scheduling Distributes more requests to servers with fewer active connections relative to their destination IPs. This algorithm is designed for use in a proxy-cache server cluster. It routes the packets for an IP address to the server for that address unless that server is above its capacity and has a server in its half load, in which case it assigns the IP address to the least loaded real server. Locality-Based Least-Connection Scheduling with Replication Scheduling Distributes more requests to servers with fewer active connections relative to their destination IPs. This algorithm is also designed for use in a proxy-cache server cluster. It differs from Locality-Based Least-Connection Scheduling by mapping the target IP address to a subset of real server nodes. Requests are then routed to the server in this subset with the lowest number of connections. If all the nodes for the destination IP are above capacity, it replicates a new server for that destination IP address by adding the real server with the least connections from the overall pool of real servers to the subset of real servers for that destination IP. The most loaded node is then dropped from the real server subset to prevent over-replication. Destination Hash Scheduling Distributes requests to the pool of real servers by looking up the destination IP in a static hash table. This algorithm is designed for use in a proxy-cache server cluster. Source Hash Scheduling Distributes requests to the pool of real servers by looking up the source IP in a static hash table. This algorithm is designed for LVS routers with multiple firewalls. Shortest Expected Delay Distributes connection requests to the server that has the shortest delay expected based on number of connections on a given server divided by its assigned weight. Never Queue A two-pronged scheduler that first finds and sends connection requests to a server that is idling, or has no connections. If there are no idling servers, the scheduler defaults to the server that has the least delay in the same manner as Shortest Expected Delay . 2.3.2. Server Weight and Scheduling The administrator of Load Balancer can assign a weight to each node in the real server pool. This weight is an integer value which is factored into any weight-aware scheduling algorithms (such as weighted least-connections) and helps the LVS router more evenly load hardware with different capabilities. Weights work as a ratio relative to one another. For instance, if one real server has a weight of 1 and the other server has a weight of 5, then the server with a weight of 5 gets 5 connections for every 1 connection the other server gets. The default value for a real server weight is 1. Although adding weight to varying hardware configurations in a real server pool can help load-balance the cluster more efficiently, it can cause temporary imbalances when a real server is introduced to the real server pool and the virtual server is scheduled using weighted least-connections. For example, suppose there are three servers in the real server pool. Servers A and B are weighted at 1 and the third, server C, is weighted at 2. If server C goes down for any reason, servers A and B evenly distributes the abandoned load. However, once server C comes back online, the LVS router sees it has zero connections and floods the server with all incoming requests until it is on par with servers A and B.	null	https://docs.redhat.com/en/documentation/Red_Hat_Enterprise_Linux/7/html/load_balancer_administration/s1-lvs-scheduling-VSA
Chapter 6. View OpenShift Data Foundation Topology	Chapter 6. View OpenShift Data Foundation Topology The topology shows the mapped visualization of the OpenShift Data Foundation storage cluster at various abstraction levels and also lets you to interact with these layers. The view also shows how the various elements compose the Storage cluster altogether. Procedure On the OpenShift Web Console, navigate to Storage Data Foundation Topology . The view shows the storage cluster and the zones inside it. You can see the nodes depicted by circular entities within the zones, which are indicated by dotted lines. The label of each item or resource contains basic information such as status and health or indication for alerts. Choose a node to view node details on the right-hand panel. You can also access resources or deployments within a node by clicking on the search/preview decorator icon. To view deployment details Click the preview decorator on a node. A modal window appears above the node that displays all of the deployments associated with that node along with their statuses. Click the Back to main view button in the model's upper left corner to close and return to the view. Select a specific deployment to see more information about it. All relevant data is shown in the side panel. Click the Resources tab to view the pods information. This tab provides a deeper understanding of the problems and offers granularity that aids in better troubleshooting. Click the pod links to view the pod information page on OpenShift Container Platform. The link opens in a new window.	null	https://docs.redhat.com/en/documentation/red_hat_openshift_data_foundation/4.15/html/deploying_openshift_data_foundation_on_vmware_vsphere/viewing-odf-topology_rhodf
Chapter 9. Removing the kubeadmin user	Chapter 9. Removing the kubeadmin user 9.1. The kubeadmin user OpenShift Container Platform creates a cluster administrator, kubeadmin , after the installation process completes. This user has the cluster-admin role automatically applied and is treated as the root user for the cluster. The password is dynamically generated and unique to your OpenShift Container Platform environment. After installation completes the password is provided in the installation program's output. For example: INFO Install complete! INFO Run 'export KUBECONFIG=<your working directory>/auth/kubeconfig' to manage the cluster with 'oc', the OpenShift CLI. INFO The cluster is ready when 'oc login -u kubeadmin -p <provided>' succeeds (wait a few minutes). INFO Access the OpenShift web-console here: https://console-openshift-console.apps.demo1.openshift4-beta-abcorp.com INFO Login to the console with user: kubeadmin, password: <provided> 9.2. Removing the kubeadmin user After you define an identity provider and create a new cluster-admin user, you can remove the kubeadmin to improve cluster security. Warning If you follow this procedure before another user is a cluster-admin , then OpenShift Container Platform must be reinstalled. It is not possible to undo this command. Prerequisites You must have configured at least one identity provider. You must have added the cluster-admin role to a user. You must be logged in as an administrator. Procedure Remove the kubeadmin secrets: USD oc delete secrets kubeadmin -n kube-system	[ "INFO Install complete! INFO Run 'export KUBECONFIG=<your working directory>/auth/kubeconfig' to manage the cluster with 'oc', the OpenShift CLI. INFO The cluster is ready when 'oc login -u kubeadmin -p <provided>' succeeds (wait a few minutes). INFO Access the OpenShift web-console here: https://console-openshift-console.apps.demo1.openshift4-beta-abcorp.com INFO Login to the console with user: kubeadmin, password: <provided>", "oc delete secrets kubeadmin -n kube-system" ]	https://docs.redhat.com/en/documentation/openshift_container_platform/4.13/html/authentication_and_authorization/removing-kubeadmin
Configuring your Red Hat build of Quarkus applications by using a YAML file	Configuring your Red Hat build of Quarkus applications by using a YAML file Red Hat build of Quarkus 3.15 Red Hat Customer Content Services	[ "<dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-config-yaml</artifactId> </dependency>", "./mvnw quarkus:add-extension -Dextensions=\"quarkus-config-yaml\"", "Properties that configure the JDBC data source driver of your PostgreSQL data source quarkus: datasource: db-kind: postgresql jdbc: url: jdbc:postgresql://localhost:5432/quarkus_test username: quarkus_test password: quarkus_test Property that configures the URL of the endpoint to which the REST client sends requests quarkus: rest-client: org.acme.rest.client.ExtensionsService: url: https://stage.code.quarkus.io/api Property that configures the log message level for your application For configuration property names that use quotes, do not split the string inside the quotes quarkus: log: category: \"io.quarkus.category\": level: INFO", "\"%dev\": quarkus: datasource: db-kind: postgresql jdbc: url: jdbc:postgresql://localhost:5432/quarkus_test username: quarkus_test password: quarkus_test", "mach: 3 x: factor: 2.23694 display: mach: USD{mach} unit: name: \"mph\" factor: USD{x.factor}", "├── config │ └── application.yaml ├── my-app-runner", "quarkus: http: cors: ~: true methods: GET,PUT,POST", "./mvnw quarkus:dev" ]	https://docs.redhat.com/en/documentation/red_hat_build_of_quarkus/3.15/html-single/configuring_your_red_hat_build_of_quarkus_applications_by_using_a_yaml_file/index
Chapter 20. Storage	Chapter 20. Storage Targetd plug-in from the libStorageMgmt API, see the section called "Storage Array Management with libStorageMgmt API" LSI Syncro CS HA-DAS adapters, see the section called "Support for LSI Syncro" DIF/DIX, see the section called "DIF/DIX Support"	null	https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/7/html/7.1_release_notes/chap-tp-storage
function::usymfileline	function::usymfileline Name function::usymfileline - Return the file name and line number of an address. Synopsis Arguments addr The address to translate. Description Returns the file name and the (approximate) line number of the given address, if known. If the file name or the line number cannot be found, the hex string representation of the address will be returned.	[ "usymfileline:string(addr:long)" ]	https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/7/html/systemtap_tapset_reference/api-usymfileline
Chapter 3. Red Hat build of OpenJDK features	Chapter 3. Red Hat build of OpenJDK features The latest Red Hat build of OpenJDK 21 release might include new features. Additionally, the latest release might enhance, deprecate, or remove features that originated from earlier Red Hat build of OpenJDK 21 releases. Note For all the other changes and security fixes, see OpenJDK 21.0.6 Released . Red Hat build of OpenJDK enhancements Red Hat build of OpenJDK 21 provides enhancements to features originally created in earlier releases of Red Hat build of OpenJDK. Option for jar command to avoid overwriting files when extracting an archive In earlier Red Hat build of OpenJDK releases, when the jar tool extracted files from an archive, the jar tool overwrote any existing files with the same name in the target directory. Red Hat build of OpenJDK 21.0.6 adds a new ‐k (or ‐‐keep-old-files ) option that you can use to ensure that the jar tool does not overwrite existing files. You can specify this new option in either short or long format. For example: jar xkf myfile.jar jar --extract ‐‐keep-old-files ‐‐file myfile.jar Note In Red Hat build of OpenJDK 21.0.6, the jar tool retains the old behavior by default. If you do not explicitly specify the ‐k (or ‐‐keep-old-files ) option, the jar tool automatically overwrites any existing files with the same name. See JDK-8335912 (JDK Bug System) and JDK bug system reference ID: JDK-8337499. IANA time zone database updated to version 2024b In Red Hat build of OpenJDK 21.0.6, the in-tree copy of the Internet Assigned Numbers Authority (IANA) time zone database is updated to version 2024b. This update is primarily concerned with improving historical data for Mexico, Mongolia, and Portugal. This update to the IANA database also includes the following changes: Asia/Choibalsan is an alias for Asia/Ulaanbaatar . The Middle European Time (MET) time zone is equal to Central European Time (CET). Some legacy time-zone IDs are mapped to geographical names rather than fixed offsets: Eastern Standard Time (EST) is mapped to America/Panama rather than -5:00 . Mountain Standard Time (MST) is mapped to America/Phoenix rather than -7:00 . Hawaii Standard Time (HST) is mapped to Pacific/Honolulu rather than -10:00 . Red Hat build of OpenJDK overrides the change in the legacy time-zone ID mappings by retaining the existing fixed-offset mapping. See JDK-8339637 (JDK Bug System) .	null	https://docs.redhat.com/en/documentation/red_hat_build_of_openjdk/21/html/release_notes_for_red_hat_build_of_openjdk_21.0.6/rn_openjdk-2106-features_openjdk
Chapter 18. Reference	Chapter 18. Reference 18.1. Data Grid Server 8.5.2 Readme Information about Data Grid Server 14.0.21.Final-redhat-00001 distribution. 18.1.1. Requirements Data Grid Server requires JDK 11 or later. 18.1.2. Starting servers Use the server script to run Data Grid Server instances. Unix / Linux Windows Tip Include the --help or -h option to view command arguments. 18.1.3. Stopping servers Use the shutdown command with the CLI to perform a graceful shutdown. Alternatively, enter Ctrl-C from the terminal to interrupt the server process or kill it via the TERM signal. 18.1.4. Configuration Server configuration extends Data Grid configuration with the following server-specific elements: cache-container Defines cache containers for managing cache lifecycles. endpoints Enables and configures endpoint connectors for client protocols. security Configures endpoint security realms. socket-bindings Maps endpoint connectors to interfaces and ports. The default configuration file is USDRHDG_HOME/server/conf/infinispan.xml . infinispan.xml Provides configuration to run Data Grid Server using default cache container with statistics and authorization enabled. Demonstrates how to set up authentication and authorization using security realms. Data Grid provides other ready-to-use configuration files that are primarily for development and testing purposes. USDRHDG_HOME/server/conf/ provides the following configuration files: infinispan-dev-mode.xml Configures Data Grid Server specifically for cross-site replication with IP multicast discovery. The configuration provides BASIC authentication to connect to the Hot Rod and REST endpoints. The configuration is designed for development mode and should not be used in production environments. infinispan-local.xml Configures Data Grid Server without clustering capabilities. infinispan-xsite.xml Configures cross-site replication on a single host and uses IP multicast for discovery. infinispan-memcached.xml Configures Data Grid Server to behave like a default Memcached server, listening on port 11221 and without authentication. infinispan-resp.xml Configures Data Grid Server to behave like a default Redis server, listening on port 6379 and without authentication. log4j2.xml Configures Data Grid Server logging. Use different configuration files with the -c argument, as in the following example that starts a server without clustering capabilities: Unix / Linux Windows 18.1.5. Bind address Data Grid Server binds to the loopback IP address localhost on your network by default. Use the -b argument to set a different IP address, as in the following example that binds to all network interfaces: Unix / Linux Windows 18.1.6. Bind port Data Grid Server listens on port 11222 by default. Use the -p argument to set an alternative port: Unix / Linux Windows 18.1.7. Clustering address Data Grid Server configuration defines cluster transport so multiple instances on the same network discover each other and automatically form clusters. Use the -k argument to change the IP address for cluster traffic: Unix / Linux Windows 18.1.8. Cluster stacks JGroups stacks configure the protocols for cluster transport. Data Grid Server uses the tcp stack by default. Use alternative cluster stacks with the -j argument, as in the following example that uses UDP for cluster transport: Unix / Linux Windows 18.1.9. Authentication Data Grid Server requires authentication. Create a username and password with the CLI as follows: Unix / Linux Windows 18.1.10. Server home directory Data Grid Server uses infinispan.server.home.path to locate the contents of the server distribution on the host filesystem. The server home directory, referred to as USDRHDG_HOME , contains the following folders: Folder Description /bin Contains scripts to start servers and CLI. /boot Contains JAR files to boot servers. /docs Provides configuration examples, schemas, component licenses, and other resources. /lib Contains JAR files that servers require internally. Do not place custom JAR files in this folder. /server Provides a root folder for Data Grid Server instances. /static Contains static resources for Data Grid Console. 18.1.11. Server root directory Data Grid Server uses infinispan.server.root.path to locate configuration files and data for Data Grid Server instances. You can create multiple server root folders in the same directory or in different directories and then specify the locations with the -s or --server-root argument, as in the following example: Unix / Linux Windows Each server root directory contains the following folders: Folder Description System property override /server/conf Contains server configuration files. infinispan.server.config.path /server/data Contains data files organized by container name. infinispan.server.data.path /server/lib Contains server extension files. This directory is scanned recursively and used as a classpath. infinispan.server.lib.path Separate multiple paths with the following delimiters: : on Unix / Linux ; on Windows /server/log Contains server log files. infinispan.server.log.path 18.1.12. Logging Configure Data Grid Server logging with the log4j2.xml file in the server/conf folder. Use the --logging-config=<path_to_logfile> argument to use custom paths, as follows: Unix / Linux Tip To ensure custom paths take effect, do not use the ~ shortcut. Windows	[ "USDRHDG_HOME/bin/server.sh", "USDRHDG_HOME\\bin\\server.bat", "USDRHDG_HOME/bin/server.sh -c infinispan-local.xml", "USDRHDG_HOME\\bin\\server.bat -c infinispan-local.xml", "USDRHDG_HOME/bin/server.sh -b 0.0.0.0", "USDRHDG_HOME\\bin\\server.bat -b 0.0.0.0", "USDRHDG_HOME/bin/server.sh -p 30000", "USDRHDG_HOME\\bin\\server.bat -p 30000", "USDRHDG_HOME/bin/server.sh -k 192.168.1.100", "USDRHDG_HOME\\bin\\server.bat -k 192.168.1.100", "USDRHDG_HOME/bin/server.sh -j udp", "USDRHDG_HOME\\bin\\server.bat -j udp", "USDRHDG_HOME/bin/cli.sh user create username -p \"qwer1234!\"", "USDRHDG_HOME\\bin\\cli.bat user create username -p \"qwer1234!\"", "├── bin ├── boot ├── docs ├── lib ├── server └── static", "USDRHDG_HOME/bin/server.sh -s server2", "USDRHDG_HOME\\bin\\server.bat -s server2", "├── server │ ├── conf │ ├── data │ ├── lib │ └── log", "USDRHDG_HOME/bin/server.sh --logging-config=/path/to/log4j2.xml", "USDRHDG_HOME\\bin\\server.bat --logging-config=path\\to\\log4j2.xml" ]	https://docs.redhat.com/en/documentation/red_hat_data_grid/8.5/html/data_grid_server_guide/server_reference
32.5.2. Check the memory dump	32.5.2. Check the memory dump When the memory dump is finished and Red Hat Enterprise Linux is rebooted, you can check the memory dump with the crash command by opening the special device file. The following example shows how to check the memory dump which is saved on /dev/sdb1. Example 32.9. Checking Dump Integrity	[ "crash /usr/lib/debug/lib/modules/2.6.32-358.el6.x86_64/vmlinux /dev/sdb1" ]	https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/6/html/deployment_guide/s2-ppc-sadump-check-memory-dump
7.261. util-linux-ng	7.261. util-linux-ng 7.261.1. RHSA-2013:0517 - Low: util-linux-ng security, bug fix and enhancement update Updated util-linux-ng packages that fix multiple bugs and add various enhancements are now available for Red Hat Enterprise Linux 6. The Red Hat Security Response Team has rated this update as having low security impact. Common Vulnerability Scoring System (CVSS) base scores, which give detailed severity ratings, are available for each vulnerability from the CVE links associated with each description below. The util-linux-ng packages contain a large variety of low-level system utilities that are necessary for a Linux operating system to function. Security Fix CVE-2013-0157 An information disclosure flaw was found in the way the mount command reported errors. A local attacker could use this flaw to determine the existence of files and directories they do not have access to. Bug Fixes BZ# 790728 Previously, the blkid utility ignored swap area UUIDs if the first byte was zero. As a consequence, the swap areas could not be addressed by UUIDs; for example, from the /etc/fstab file. The libblkd library has been fixed and now swap partitions are labeled with a valid UUID value if the first byte is zero. BZ# 818621 Previously, the lsblk utility opened block devices to check if the device was in read-only mode, although the information was available in the /sys file system. This resulted in unexpected SELinux alerts and unnecessary open() calls. Now, the lsblk utility does not perform unnecessary opening operations and no longer reads the information from the /sys file system. BZ#736245 On a non-uniform CPU configuration, for example on a system with two sockets with a different number of cores, the lscpu command failed unexpectedly with a segmentation fault and a core dump was generated. After this update, when executing the lscpu command on such a configuration, the correct result is printed and no core dump is generated. BZ#837935 On a system with a large number of active processors, the lscpu command failed unexpectedly with a segmentation fault and a core dump was generated. This bug is now fixed and the lscpu command now works as expected on this configuration. BZ#819945 Executing the hwclock --systz command to reset the system time based on the current time zone caused the clock to be incorrectly adjusted by one hour. This was because hwclock did not adjust the system time during boot according to the "warp clock" semantic described in the settimeofday(2) man page. With this update, hwclock correctly sets the system time when required. BZ#845477 When SElinux options were specified both in the /etc/fstab file and on the command line, mounting failed and the kernel logged the following error upon running dmesg : The handling of SElinux options has been changed so that options on the command line now replace options given in the /etc/fstab file and as a result, devices can be mounted successfully. BZ#845971 Due to a change in the search order of the mount utility, while reading the /etc/fstab file, the mount command returned a device before a directory. With this update, the search order has been modified and mount now works as expected. BZ#858009 Previously, any new login or logout sequence by a telnet client caused the /var/run/utmp file to increase by one record on the telnetd machine. As a consequence, the /var/run/utmp file grew without a limit. As a result of trying to search though a huge /var/run/utmp file, the machine running telnetd could experience more severe side-effects over time. For example, the telnetd process could become unresponsive or the overall system performance could degrade. The telnetd now creates a proper record in /var/run/utmp before starting the logging process. As a result, the /var/run/utmp does not grow without a limit on each new login or logout sequence of a telnet session. BZ#730891, BZ# 783514 , BZ#809139, BZ#820183, BZ# 839281 Man pages of several utilities included in the package have been updated to fix minor mistakes and add entries for previously undocumented functionalities. Enhancements BZ#719927 A new --compare option for hwclock to compare the offset between system time and hardware clock has been added due to a discontinued distribution of adjtimex in Red Hat Enterprise Linux 6.0 and later, which had previously provided this option. BZ#809449 The lsblk command now supports a new option, --inverse , used to print dependencies between block devices in reverse order. This feature is required to properly reboot or shut down systems with a configured cluster. BZ#823008 The lscpu utility, which displays detailed information about the available CPUs, has been updated to include numerous new features. Also, a new utility, chcpu , has been added, which allows the user to change the CPU state (online or offline, standby or active, and other states), disable and enable CPUs, and configure specified CPUs. For more information about these utilities, refer to the lscpu(1) and chcpu(8) man pages. Users of util-linux-ng are advised to upgrade to these updated packages, which fix these bugs and add these enhancements.	[ "SELinux: duplicate or incompatible mount options" ]	https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/6/html/6.4_technical_notes/util-linux-ng
Automating system administration by using RHEL System Roles in RHEL 7.9	Automating system administration by using RHEL System Roles in RHEL 7.9 Red Hat Enterprise Linux 7 Consistent and repeatable configuration of RHEL deployments across multiple hosts with Red Hat Ansible Automation Platform playbooks Red Hat Customer Content Services	null	https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/7/html/automating_system_administration_by_using_rhel_system_roles_in_rhel_7.9/index
Chapter 12. Creating and executing DMN and BPMN models using Maven	Chapter 12. Creating and executing DMN and BPMN models using Maven You can use Maven archetypes to develop DMN and BPMN models in VS Code using the Red Hat Process Automation Manager VS Code extension instead of Business Central. You can then integrate your archetypes with your Red Hat Process Automation Manager decision and process services in Business Central as needed. This method of developing DMN and BPMN models is helpful for building new business applications using the Red Hat Process Automation Manager VS Code extension. Procedure In a command terminal, navigate to a local folder where you want to store the new Red Hat Process Automation Manager project. Enter the following command to use a Maven archtype to generate a project within a defined folder: Generating a project using Maven archetype This command generates a Maven project with required dependencies and generates required directories and files to build your business application. You can use the Git version control system (recommended) when developing a project. If you want to generate multiple projects in the same directory, specify the artifactId and groupId of the generated business application by adding -DgroupId=<groupid> -DartifactId=<artifactId> to the command. In your VS Code IDE, click File , select Open Folder , and navigate to the folder that is generated using the command. Before creating the first asset, set a package for your business application, for example, org.kie.businessapp , and create respective directories in the following paths: PROJECT_HOME/src/main/java PROJECT_HOME/src/main/resources PROJECT_HOME/src/test/resources For example, you can create PROJECT_HOME/src/main/java/org/kie/businessapp for org.kie.businessapp package. Use VS Code to create assets for your business application. You can create the assets supported by Red Hat Process Automation Manager VS Code extension using the following ways: To create a business process, create a new file with .bpmn or .bpmn2 in PROJECT_HOME/src/main/resources/org/kie/businessapp directory, such as Process.bpmn . To create a DMN model, create a new file with .dmn in PROJECT_HOME/src/main/resources/org/kie/businessapp directory, such as AgeDecision.dmn . To create a test scenario simulation model, create a new file with .scesim in PROJECT_HOME/src/test/resources/org/kie/businessapp directory, such as TestAgeScenario.scesim . After you create the assets in your Maven archetype, navigate to the root directory (contains pom.xml ) of the project in the command line and run the following command to build the knowledge JAR (KJAR) of your project: If the build fails, address any problems described in the command line error messages and try again to validate the project until the build is successful. However, if the build is successful, you can find the artifact of your business application in PROJECT_HOME/target directory. Note Use mvn clean install command often to validate your project after each major change during development. You can deploy the generated knowledge JAR (KJAR) of your business application on a running KIE Server using the REST API. For more information about using REST API, see Interacting with Red Hat Process Automation Manager using KIE APIs .	[ "mvn archetype:generate -DarchetypeGroupId=org.kie -DarchetypeArtifactId=kie-kjar-archetype -DarchetypeVersion=7.67.0.Final-redhat-00024", "mvn clean install" ]	https://docs.redhat.com/en/documentation/red_hat_process_automation_manager/7.13/html/getting_started_with_red_hat_process_automation_manager/proc-dmn-bpmn-maven-create_getting-started-process-services
4.244. python-dmidecode	4.244. python-dmidecode 4.244.1. RHBA-2011:1589 - python-dmidecode bug fix update An updated python-dmidecode package that fixes various bugs is now available for Red Hat Enterprise Linux 6. The python-dmidecode package provides a python extension module that uses the code-base of the dmidecode utility and presents the data as python data structures or as XML data using the libxml2 library. The python-dmidecode package has been upgraded to upstream version 3.10.13, which provides a number of bug fixes over the version. (BZ# 621567 ) Bug Fixes BZ# 627901 When trying to identify the processor type by performing a string comparison, Python terminated with a segmentation fault. This was caused by DMI tables which did not report the CPU processor information as a string and returned a NULL value instead. This update adds additional checks for NULL values before doing the string comparison. BZ# 646429 Previously, when calling the memcpy() function on the IBM System z machine which was under heavy memory load, a SIGILL signal was triggered. As a consequence, the complete Python interpreter core dumped. A signal handler was added to properly handle heavy memory loads. BZ# 667363 Prior to this update, when running the rhn_register utility, providing a valid user name and password, and clicking the Forward button, the tool terminated unexpectedly with a segmentation fault. This was caused by the dmi_processor_id() function not checking whether the version pointer was NULL. This update adds additional checks for NULL values, fixing the problem. All users of python-dmidecode are advised to upgrade to this updated package, which resolves these bugs.	null	https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/6/html/6.2_technical_notes/python-dmidecode
4.334. usbutils	4.334. usbutils 4.334.1. RHBA-2011:1646 - usbutils bug fix and enhancement update An updated usbutils package that fixes several bugs and adds various enhancements is now available for Red Hat Enterprise Linux 6. The usbutils package contains utilities for inspecting devices connected to a USB bus. The usbutils package has been upgraded to upstream version 003, which adds support for USB3 devices. Note: warning messages about short transfer on control endpoint and stalled endpoint can under circumstances be logged after the upgrade. This is the standard behavior of the xHCI driver and these messages can be safely ignored. This update also provides a number of bug fixes and enhancements over the version. (BZ# 725973 , BZ# 725096 ) Bug Fixes BZ# 725982 Previously, when running the "lsusb -t" command in a KVM guest, the lsusb utility terminated with a segmentation fault. The utility has been modified and now lists USB devices correctly. BZ# 730671 The FILES item in the lsusb(8) manual page displayed an incorrect path to the usb.ids file. This path has been changed to the correct /usr/share/hwdata/usb.ids path. All users of usbutils are advised to upgrade to this updated usbutils package, which fixes these bugs and adds these enhancements.	null	https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/6/html/6.2_technical_notes/usbutils
23.8. Enforcing a Specific Authentication Indicator When Obtaining a Ticket from the KDC	23.8. Enforcing a Specific Authentication Indicator When Obtaining a Ticket from the KDC To enforce a specific authentication indicator on: A host object, execute: A Kerberos service, execute: To set multiple authentication indicators, specify the --auth-ind parameter multiple times. Warning Setting an authentication indicator to the HTTP/ IdM_master service causes the IdM master to fail. Additionally, the utilities provided by IdM do not enable you to restore the master. Example 23.2. Enforcing the pkinit Indicator on a Specific Host The following command configures that only the users authenticated through a smart card can obtain a service ticket for the host.idm.example.com host: The setting above ensures that the ticket-granting ticket (TGT) of a user requesting a Kerberos ticket, contains the pkinit authentication indicator.	[ "ipa host-mod host_name --auth-ind= indicator", "ipa service-mod service / host_name --auth-ind= indicator", "ipa host-mod host.idm.example.com --auth-ind=pkinit" ]	https://docs.redhat.com/en/documentation/Red_Hat_Enterprise_Linux/7/html/linux_domain_identity_authentication_and_policy_guide/enforcing-a-specific-authentication-indicator-when-obtaining-a-ticket-from-the-kdc
Chapter 1. Adding a custom application configuration file to Red Hat OpenShift Container Platform	Chapter 1. Adding a custom application configuration file to Red Hat OpenShift Container Platform To access the Red Hat Developer Hub, you must add a custom application configuration file to Red Hat OpenShift Container Platform. In OpenShift Container Platform, you can use the following content as a base template to create a ConfigMap named app-config-rhdh : kind: ConfigMap apiVersion: v1 metadata: name: app-config-rhdh data: app-config-rhdh.yaml: \| app: title: Red Hat Developer Hub You can add the custom application configuration file to OpenShift Container Platform in one of the following ways: The Red Hat Developer Hub Operator The Red Hat Developer Hub Helm chart 1.1. Adding a custom application configuration file to OpenShift Container Platform using the Helm chart You can use the Red Hat Developer Hub Helm chart to add a custom application configuration file to your OpenShift Container Platform instance. Prerequisites You have created an Red Hat OpenShift Container Platform account. Procedure From the OpenShift Container Platform web console, select the ConfigMaps tab. Click Create ConfigMap . From Create ConfigMap page, select the YAML view option in Configure via and make changes to the file, if needed. Click Create . Go to the Helm tab to see the list of Helm releases. Click the overflow menu on the Helm release that you want to use and select Upgrade . Use either the Form view or YAML view to edit the Helm configuration. Using Form view Expand Root Schema Backstage chart schema Backstage parameters Extra app configuration files to inline into command arguments . Click the Add Extra app configuration files to inline into command arguments link. Enter the value in the following fields: configMapRef : app-config-rhdh filename : app-config-rhdh.yaml Click Upgrade . Using YAML view Set the value of the upstream.backstage.extraAppConfig.configMapRef and upstream.backstage.extraAppConfig.filename parameters as follows: # ... other Red Hat Developer Hub Helm Chart configurations upstream: backstage: extraAppConfig: - configMapRef: app-config-rhdh filename: app-config-rhdh.yaml # ... other Red Hat Developer Hub Helm Chart configurations Click Upgrade . 1.2. Adding a custom application configuration file to OpenShift Container Platform using the Operator A custom application configuration file is a ConfigMap object that you can use to change the configuration of your Red Hat Developer Hub instance. If you are deploying your Developer Hub instance on Red Hat OpenShift Container Platform, you can use the Red Hat Developer Hub Operator to add a custom application configuration file to your OpenShift Container Platform instance by creating the ConfigMap object and referencing it in the Developer Hub custom resource (CR). The custom application configuration file contains a sensitive environment variable, named BACKEND_SECRET . This variable contains a mandatory backend authentication key that Developer Hub uses to reference an environment variable defined in an OpenShift Container Platform secret. You must create a secret, named 'secrets-rhdh', and reference it in the Developer Hub CR. Note You are responsible for protecting your Red Hat Developer Hub installation from external and unauthorized access. Manage the backend authentication key like any other secret. Meet strong password requirements, do not expose it in any configuration files, and only inject it into configuration files as an environment variable. Prerequisites You have an active Red Hat OpenShift Container Platform account. Your administrator has installed the Red Hat Developer Hub Operator in OpenShift Container Platform. For more information, see Installing the Red Hat Developer Hub Operator . You have created the Red Hat Developer Hub CR in OpenShift Container Platform. Procedure From the Developer perspective in the OpenShift Container Platform web console, select the Topology view, and click the Open URL icon on the Developer Hub pod to identify your Developer Hub external URL: <RHDH_URL> . From the Developer perspective in the OpenShift Container Platform web console, select the ConfigMaps view. Click Create ConfigMap . Select the YAML view option in Configure via and use the following example as a base template to create a ConfigMap object, such as app-config-rhdh.yaml : kind: ConfigMap apiVersion: v1 metadata: name: app-config-rhdh data: "app-config-rhdh.yaml": \| app: title: Red Hat Developer Hub baseUrl: <RHDH_URL> 1 backend: auth: externalAccess: - type: legacy options: subject: legacy-default-config secret: "USD{BACKEND_SECRET}" 2 baseUrl: <RHDH_URL> 3 cors: origin: <RHDH_URL> 4 1 Set the external URL of your Red Hat Developer Hub instance. 2 Use an environment variable exposing an OpenShift Container Platform secret to define the mandatory Developer Hub backend authentication key. 3 Set the external URL of your Red Hat Developer Hub instance. 4 Set the external URL of your Red Hat Developer Hub instance. Click Create . Select the Secrets view. Click Create Key/value Secret . Create a secret named secrets-rhdh . Add a key named BACKEND_SECRET and a base64 encoded string as a value. Use a unique value for each Red Hat Developer Hub instance. For example, you can use the following command to generate a key from your terminal: node -p 'require("crypto").randomBytes(24).toString("base64")' Click Create . Select the Topology view. Click the overflow menu for the Red Hat Developer Hub instance that you want to use and select Edit Backstage to load the YAML view of the Red Hat Developer Hub instance. In the CR, enter the name of the custom application configuration config map as the value for the spec.application.appConfig.configMaps field, and enter the name of your secret as the value for the spec.application.extraEnvs.secrets field. For example: apiVersion: rhdh.redhat.com/v1alpha1 kind: Backstage metadata: name: developer-hub spec: application: appConfig: mountPath: /opt/app-root/src configMaps: - name: app-config-rhdh extraEnvs: secrets: - name: secrets-rhdh extraFiles: mountPath: /opt/app-root/src replicas: 1 route: enabled: true database: enableLocalDb: true Click Save . Navigate back to the Topology view and wait for the Red Hat Developer Hub pod to start. Click the Open URL icon to use the Red Hat Developer Hub platform with the configuration changes. Additional resources For more information about roles and responsibilities in Developer Hub, see Role-Based Access Control (RBAC) in Red Hat Developer Hub .	[ "kind: ConfigMap apiVersion: v1 metadata: name: app-config-rhdh data: app-config-rhdh.yaml: \| app: title: Red Hat Developer Hub", "... other Red Hat Developer Hub Helm Chart configurations upstream: backstage: extraAppConfig: - configMapRef: app-config-rhdh filename: app-config-rhdh.yaml ... other Red Hat Developer Hub Helm Chart configurations", "kind: ConfigMap apiVersion: v1 metadata: name: app-config-rhdh data: \"app-config-rhdh.yaml\": \| app: title: Red Hat Developer Hub baseUrl: <RHDH_URL> 1 backend: auth: externalAccess: - type: legacy options: subject: legacy-default-config secret: \"USD{BACKEND_SECRET}\" 2 baseUrl: <RHDH_URL> 3 cors: origin: <RHDH_URL> 4", "node -p 'require(\"crypto\").randomBytes(24).toString(\"base64\")'", "apiVersion: rhdh.redhat.com/v1alpha1 kind: Backstage metadata: name: developer-hub spec: application: appConfig: mountPath: /opt/app-root/src configMaps: - name: app-config-rhdh extraEnvs: secrets: - name: secrets-rhdh extraFiles: mountPath: /opt/app-root/src replicas: 1 route: enabled: true database: enableLocalDb: true" ]	https://docs.redhat.com/en/documentation/red_hat_developer_hub/1.3/html/administration_guide_for_red_hat_developer_hub/assembly-add-custom-app-file-openshift_admin-rhdh
Chapter 1. OpenShift Dedicated cluster upgrades	Chapter 1. OpenShift Dedicated cluster upgrades You can schedule automatic or manual upgrade policies to update the version of your OpenShift Dedicated clusters. Upgrading OpenShift Dedicated clusters can be done through Red Hat OpenShift Cluster Manager or OpenShift Cluster Manager CLI. Red Hat Site Reliability Engineers (SREs) monitor upgrade progress and remedy any issues encountered. 1.1. Life cycle policies and planning To plan an upgrade, review the OpenShift Dedicated update life cycle guide in the "Additional resources" section. The life cycle page includes release definitions, support and upgrade requirements, installation policy information, and life cycle dates. You can use update channels to decide which Red Hat OpenShift Container Platform minor version to update your clusters to. OpenShift Dedicated supports updates only through the stable channel. To learn more about OpenShift update channels and releases, see Understanding update channels and releases . Additional resources For more information about the OpenShift Dedicated life cycle policy, see OpenShift Dedicated update life cycle . 1.2. Understanding OpenShift Dedicated cluster upgrades When upgrades are made available for your OpenShift Dedicated cluster, you can upgrade to the newest version through Red Hat OpenShift Cluster Manager or OpenShift Cluster Manager CLI. You can set your upgrade policies on existing clusters or during cluster creation, and upgrades can be scheduled to occur automatically or manually. Important Before upgrading a Workload Identity Federation (WIF)-enabled OpenShift Dedicated on Google Cloud Platform (GCP) cluster, you must update the wif-config. For more information, see "Cluster upgrades with Workload Identity Federation (WIF)". Red Hat Site Reliability Engineers (SRE) will provide a curated list of available versions for your OpenShift Dedicated clusters. For each cluster you will be able to review the full list of available releases, as well as the corresponding release notes. OpenShift Cluster Manager will enable installation of clusters at the latest supported versions, and upgrades can be canceled at any time. You can also set a grace period for how long PodDisruptionBudget protected workloads are respected during upgrades. After this grace period, any workloads protected by PodDisruptionBudget that have not been successfully drained from a node, will be forcibly deleted. Note All Kubernetes objects and PVs in each OpenShift Dedicated cluster are backed up as part of the OpenShift Dedicated service. Application and application data backups are not a part of the OpenShift Dedicated service. Ensure you have a backup policy in place for your applications and application data prior to scheduling upgrades. Note When following a scheduled upgrade policy, there might be a delay of an hour or more before the upgrade process begins, even if it is an immediate upgrade. Additionally, the duration of the upgrade might vary based on your workload configuration. 1.2.1. Recurring upgrades Upgrades can be scheduled to occur automatically on a day and time specified by the cluster owner or administrator. Upgrades occur on a weekly basis, unless an upgrade is unavailable for that week. If you select recurring updates for your cluster, you must provide an administrator's acknowledgment. OpenShift Cluster Manager does not start scheduled y-stream updates for minor versions without receiving an administrator's acknowledgment. Note Recurring upgrade policies are optional and if they are not set, the upgrade policies default to individual. 1.2.2. Individual upgrades If you opt for individual upgrades, you are responsible for updating your cluster. If you select an update version that requires approval, you must provide an administrator's acknowledgment. If your cluster version becomes outdated, it will transition to a limited support status. For more information on OpenShift life cycle policies, see OpenShift Dedicated update life cycle . 1.2.3. Upgrade notifications From OpenShift Cluster Manager console you can view your cluster's history from the Overview tab. The Upgrade states can be viewed in the service log under the Cluster history heading. Every change of state also triggers an email notification to the cluster owner and subscribed users. You will receive email notifications for the following events: An upgrade has been scheduled. An upgrade has started. An upgrade has completed. An upgrade has been canceled. Note For recurring upgrades, you will also receive email notifications before the upgrade occurs based on the following cadence: 2 week notice 1 week notice 1 day notice 1.2.4. Cluster upgrades with Workload Identity Federation (WIF) Before upgrading an OpenShift Dedicated on Google Cloud Platform (GCP) cluster with WIF authentication type to a newer y-stream version, you must update the WIF configuration to that version as well. Failure to do so before attempting to upgrade the cluster version will result in an error. For more information on how to update a WIF configuration, see the Additional resources section. Note The update path to a brand new release of OpenShift Dedicated is not available in the stable channel until 45 to 90 days after the initial GA of a newer y-stream version. Additional resources For more information about the service log and adding cluster notification contacts, see Accessing cluster notifications in Red Hat Hybrid Cloud Console . For more information on how to update a WIF configuration, see Updating a WIF configuration . 1.3. Scheduling recurring upgrades for your cluster You can use OpenShift Cluster Manager to schedule recurring, automatic upgrades for z-stream patch versions for your OpenShift Dedicated cluster. Based on upstream changes, there might be times when no updates are released. Therefore, no upgrade occurs for that week. Procedure From OpenShift Cluster Manager , select your cluster from the clusters list. Click the Upgrade settings tab to access the upgrade operator. To schedule recurring upgrades, select Recurring updates . Provide an administrator's acknowledgment and click Approve and continue . OpenShift Cluster Manager does not start scheduled y-stream updates for minor versions without receiving an administrator's acknowledgment. Important Before upgrading a Workload Identity Federation (WIF)-enabled OpenShift Dedicated on Google Cloud Platform (GCP) cluster, you must update the wif-config. For more information, see "Cluster upgrades with Workload Identity Federation (WIF)". Specify the day of the week and the time you want your cluster to upgrade. Click Save . Optional: Set a grace period for Node draining by selecting a designated amount of time from the drop down list. A 1 hour grace period is set by default. To edit an existing recurring upgrade policy, edit the preferred day or start time from the Upgrade Settings tab. Click Save . To cancel a recurring upgrade policy, switch the upgrade method to individual from the Upgrade Settings tab. Click Save . On the Upgrade settings tab, the Upgrade status box indicates that an upgrade is scheduled. The date and time of the scheduled update is listed. 1.4. Scheduling individual upgrades for your cluster You can use OpenShift Cluster Manager to manually upgrade your OpenShift Dedicated cluster one time. Procedure From OpenShift Cluster Manager , select your cluster from the clusters list. Click the Upgrade settings tab to access the upgrade operator. You can also update your cluster from the Overview tab by clicking Update to the cluster version under the Details heading. To schedule an individual upgrade, select Individual updates . Click Update in the Update Status box. Select the version you want to upgrade your cluster to. Recommended cluster upgrades appear in the UI. To learn more about each available upgrade version, click View release notes . If you select an update version that requires approval, provide an administrator's acknowledgment and click Approve and continue . Important Before upgrading a Workload Identity Federation (WIF)-enabled OpenShift Dedicated on Google Cloud Platform (GCP) cluster, you must update the wif-config. For more information, see "Cluster upgrades with Workload Identity Federation (WIF)". Click . To schedule your upgrade: Click Upgrade now to upgrade within the hour. Click Schedule a different time and specify the date and time that you want the cluster to upgrade. Click . Review the upgrade policy and click Confirm upgrade . A confirmation appears when the cluster upgrade has been scheduled. Click Close . Optional: Set a grace period for Node draining by selecting a designated amount of time from the drop down list. A 1 hour grace period is set by default. From the Overview tab, to the cluster version, the UI notates that the upgrade has been scheduled. Click View details to view the upgrade details. If you need to cancel the scheduled upgrade, you can click Cancel this upgrade from the View Details pop-up. The same upgrade details are available on the Upgrade settings tab under the Upgrade status box. If you need to cancel the scheduled upgrade, you can click Cancel this upgrade from the Upgrade status box. Warning In the event that a CVE or other critical issue to OpenShift Dedicated is found, all clusters are upgraded within 48 hours of the fix being released. You are notified when the fix is available and informed that the cluster will be automatically upgraded at your latest preferred start time before the 48 hour window closes. You can also upgrade manually at any time before the recurring upgrade starts.	null	https://docs.redhat.com/en/documentation/openshift_dedicated/4/html/upgrading/osd-upgrades
Chapter 7. Conclusion	Chapter 7. Conclusion Congratulations. In this tutorial, you learned how to incorporate data science, artificial intelligence, and machine learning into an OpenShift development workflow. You used an example fraud detection model and completed the following tasks: Explored a pre-trained fraud detection model by using a Jupyter notebook. Deployed the model by using OpenShift AI model serving. Refined and trained the model by using automated pipelines. Learned how to train the model by using Ray, a distributed computing framework.	null	https://docs.redhat.com/en/documentation/red_hat_openshift_ai_cloud_service/1/html/openshift_ai_tutorial_-_fraud_detection_example/conclusion-tutorial
Chapter 10. Using config maps with applications	Chapter 10. Using config maps with applications Config maps allow you to decouple configuration artifacts from image content to keep containerized applications portable. The following sections define config maps and how to create and use them. For information on creating config maps, see Creating and using config maps . 10.1. Understanding config maps Many applications require configuration by using some combination of configuration files, command line arguments, and environment variables. In OpenShift Container Platform, these configuration artifacts are decoupled from image content to keep containerized applications portable. The ConfigMap object provides mechanisms to inject containers with configuration data while keeping containers agnostic of OpenShift Container Platform. A config map can be used to store fine-grained information like individual properties or coarse-grained information like entire configuration files or JSON blobs. The ConfigMap object holds key-value pairs of configuration data that can be consumed in pods or used to store configuration data for system components such as controllers. For example: ConfigMap Object Definition kind: ConfigMap apiVersion: v1 metadata: creationTimestamp: 2016-02-18T19:14:38Z name: example-config namespace: my-namespace data: 1 example.property.1: hello example.property.2: world example.property.file: \|- property.1=value-1 property.2=value-2 property.3=value-3 binaryData: bar: L3Jvb3QvMTAw 2 1 Contains the configuration data. 2 Points to a file that contains non-UTF8 data, for example, a binary Java keystore file. Enter the file data in Base 64. Note You can use the binaryData field when you create a config map from a binary file, such as an image. Configuration data can be consumed in pods in a variety of ways. A config map can be used to: Populate environment variable values in containers Set command-line arguments in a container Populate configuration files in a volume Users and system components can store configuration data in a config map. A config map is similar to a secret, but designed to more conveniently support working with strings that do not contain sensitive information. Config map restrictions A config map must be created before its contents can be consumed in pods. Controllers can be written to tolerate missing configuration data. Consult individual components configured by using config maps on a case-by-case basis. ConfigMap objects reside in a project. They can only be referenced by pods in the same project. The Kubelet only supports the use of a config map for pods it gets from the API server. This includes any pods created by using the CLI, or indirectly from a replication controller. It does not include pods created by using the OpenShift Container Platform node's --manifest-url flag, its --config flag, or its REST API because these are not common ways to create pods. 10.2. Use cases: Consuming config maps in pods The following sections describe some uses cases when consuming ConfigMap objects in pods. 10.2.1. Populating environment variables in containers by using config maps You can use config maps to populate individual environment variables in containers or to populate environment variables in containers from all keys that form valid environment variable names. As an example, consider the following config map: ConfigMap with two environment variables apiVersion: v1 kind: ConfigMap metadata: name: special-config 1 namespace: default 2 data: special.how: very 3 special.type: charm 4 1 Name of the config map. 2 The project in which the config map resides. Config maps can only be referenced by pods in the same project. 3 4 Environment variables to inject. ConfigMap with one environment variable apiVersion: v1 kind: ConfigMap metadata: name: env-config 1 namespace: default data: log_level: INFO 2 1 Name of the config map. 2 Environment variable to inject. Procedure You can consume the keys of this ConfigMap in a pod using configMapKeyRef sections. Sample Pod specification configured to inject specific environment variables apiVersion: v1 kind: Pod metadata: name: dapi-test-pod spec: containers: - name: test-container image: gcr.io/google_containers/busybox command: [ "/bin/sh", "-c", "env" ] env: 1 - name: SPECIAL_LEVEL_KEY 2 valueFrom: configMapKeyRef: name: special-config 3 key: special.how 4 - name: SPECIAL_TYPE_KEY valueFrom: configMapKeyRef: name: special-config 5 key: special.type 6 optional: true 7 envFrom: 8 - configMapRef: name: env-config 9 restartPolicy: Never 1 Stanza to pull the specified environment variables from a ConfigMap . 2 Name of a pod environment variable that you are injecting a key's value into. 3 5 Name of the ConfigMap to pull specific environment variables from. 4 6 Environment variable to pull from the ConfigMap . 7 Makes the environment variable optional. As optional, the pod will be started even if the specified ConfigMap and keys do not exist. 8 Stanza to pull all environment variables from a ConfigMap . 9 Name of the ConfigMap to pull all environment variables from. When this pod is run, the pod logs will include the following output: Note SPECIAL_TYPE_KEY=charm is not listed in the example output because optional: true is set. 10.2.2. Setting command-line arguments for container commands with config maps You can use a config map to set the value of the commands or arguments in a container by using the Kubernetes substitution syntax USD(VAR_NAME) . As an example, consider the following config map: apiVersion: v1 kind: ConfigMap metadata: name: special-config namespace: default data: special.how: very special.type: charm Procedure To inject values into a command in a container, you must consume the keys you want to use as environment variables. Then you can refer to them in a container's command using the USD(VAR_NAME) syntax. Sample pod specification configured to inject specific environment variables apiVersion: v1 kind: Pod metadata: name: dapi-test-pod spec: containers: - name: test-container image: gcr.io/google_containers/busybox command: [ "/bin/sh", "-c", "echo USD(SPECIAL_LEVEL_KEY) USD(SPECIAL_TYPE_KEY)" ] 1 env: - name: SPECIAL_LEVEL_KEY valueFrom: configMapKeyRef: name: special-config key: special.how - name: SPECIAL_TYPE_KEY valueFrom: configMapKeyRef: name: special-config key: special.type restartPolicy: Never 1 Inject the values into a command in a container using the keys you want to use as environment variables. When this pod is run, the output from the echo command run in the test-container container is as follows: 10.2.3. Injecting content into a volume by using config maps You can inject content into a volume by using config maps. Example ConfigMap custom resource (CR) apiVersion: v1 kind: ConfigMap metadata: name: special-config namespace: default data: special.how: very special.type: charm Procedure You have a couple different options for injecting content into a volume by using config maps. The most basic way to inject content into a volume by using a config map is to populate the volume with files where the key is the file name and the content of the file is the value of the key: apiVersion: v1 kind: Pod metadata: name: dapi-test-pod spec: containers: - name: test-container image: gcr.io/google_containers/busybox command: [ "/bin/sh", "-c", "cat", "/etc/config/special.how" ] volumeMounts: - name: config-volume mountPath: /etc/config volumes: - name: config-volume configMap: name: special-config 1 restartPolicy: Never 1 File containing key. When this pod is run, the output of the cat command will be: You can also control the paths within the volume where config map keys are projected: apiVersion: v1 kind: Pod metadata: name: dapi-test-pod spec: containers: - name: test-container image: gcr.io/google_containers/busybox command: [ "/bin/sh", "-c", "cat", "/etc/config/path/to/special-key" ] volumeMounts: - name: config-volume mountPath: /etc/config volumes: - name: config-volume configMap: name: special-config items: - key: special.how path: path/to/special-key 1 restartPolicy: Never 1 Path to config map key. When this pod is run, the output of the cat command will be:	[ "kind: ConfigMap apiVersion: v1 metadata: creationTimestamp: 2016-02-18T19:14:38Z name: example-config namespace: my-namespace data: 1 example.property.1: hello example.property.2: world example.property.file: \|- property.1=value-1 property.2=value-2 property.3=value-3 binaryData: bar: L3Jvb3QvMTAw 2", "apiVersion: v1 kind: ConfigMap metadata: name: special-config 1 namespace: default 2 data: special.how: very 3 special.type: charm 4", "apiVersion: v1 kind: ConfigMap metadata: name: env-config 1 namespace: default data: log_level: INFO 2", "apiVersion: v1 kind: Pod metadata: name: dapi-test-pod spec: containers: - name: test-container image: gcr.io/google_containers/busybox command: [ \"/bin/sh\", \"-c\", \"env\" ] env: 1 - name: SPECIAL_LEVEL_KEY 2 valueFrom: configMapKeyRef: name: special-config 3 key: special.how 4 - name: SPECIAL_TYPE_KEY valueFrom: configMapKeyRef: name: special-config 5 key: special.type 6 optional: true 7 envFrom: 8 - configMapRef: name: env-config 9 restartPolicy: Never", "SPECIAL_LEVEL_KEY=very log_level=INFO", "apiVersion: v1 kind: ConfigMap metadata: name: special-config namespace: default data: special.how: very special.type: charm", "apiVersion: v1 kind: Pod metadata: name: dapi-test-pod spec: containers: - name: test-container image: gcr.io/google_containers/busybox command: [ \"/bin/sh\", \"-c\", \"echo USD(SPECIAL_LEVEL_KEY) USD(SPECIAL_TYPE_KEY)\" ] 1 env: - name: SPECIAL_LEVEL_KEY valueFrom: configMapKeyRef: name: special-config key: special.how - name: SPECIAL_TYPE_KEY valueFrom: configMapKeyRef: name: special-config key: special.type restartPolicy: Never", "very charm", "apiVersion: v1 kind: ConfigMap metadata: name: special-config namespace: default data: special.how: very special.type: charm", "apiVersion: v1 kind: Pod metadata: name: dapi-test-pod spec: containers: - name: test-container image: gcr.io/google_containers/busybox command: [ \"/bin/sh\", \"-c\", \"cat\", \"/etc/config/special.how\" ] volumeMounts: - name: config-volume mountPath: /etc/config volumes: - name: config-volume configMap: name: special-config 1 restartPolicy: Never", "very", "apiVersion: v1 kind: Pod metadata: name: dapi-test-pod spec: containers: - name: test-container image: gcr.io/google_containers/busybox command: [ \"/bin/sh\", \"-c\", \"cat\", \"/etc/config/path/to/special-key\" ] volumeMounts: - name: config-volume mountPath: /etc/config volumes: - name: config-volume configMap: name: special-config items: - key: special.how path: path/to/special-key 1 restartPolicy: Never", "very" ]	https://docs.redhat.com/en/documentation/openshift_container_platform/4.11/html/building_applications/config-maps
7.3. Colocation of Resources	7.3. Colocation of Resources A colocation constraint determines that the location of one resource depends on the location of another resource. There is an important side effect of creating a colocation constraint between two resources: it affects the order in which resources are assigned to a node. This is because you cannot place resource A relative to resource B unless you know where resource B is. So when you are creating colocation constraints, it is important to consider whether you should colocate resource A with resource B or resource B with resource A. Another thing to keep in mind when creating colocation constraints is that, assuming resource A is colocated with resource B, the cluster will also take into account resource A's preferences when deciding which node to choose for resource B. The following command creates a colocation constraint. For information on master and slave resources, see Section 9.2, "Multistate Resources: Resources That Have Multiple Modes" . Table 7.4, "Properties of a Colocation Constraint" . summarizes the properties and options for configuring colocation constraints. Table 7.4. Properties of a Colocation Constraint Field Description source_resource The colocation source. If the constraint cannot be satisfied, the cluster may decide not to allow the resource to run at all. target_resource The colocation target. The cluster will decide where to put this resource first and then decide where to put the source resource. score Positive values indicate the resource should run on the same node. Negative values indicate the resources should not run on the same node. A value of + INFINITY , the default value, indicates that the source_resource must run on the same node as the target_resource . A value of - INFINITY indicates that the source_resource must not run on the same node as the target_resource . 7.3.1. Mandatory Placement Mandatory placement occurs any time the constraint's score is +INFINITY or -INFINITY . In such cases, if the constraint cannot be satisfied, then the source_resource is not permitted to run. For score=INFINITY , this includes cases where the target_resource is not active. If you need myresource1 to always run on the same machine as myresource2 , you would add the following constraint: Because INFINITY was used, if myresource2 cannot run on any of the cluster nodes (for whatever reason) then myresource1 will not be allowed to run. Alternatively, you may want to configure the opposite, a cluster in which myresource1 cannot run on the same machine as myresource2 . In this case use score=-INFINITY Again, by specifying -INFINITY , the constraint is binding. So if the only place left to run is where myresource2 already is, then myresource1 may not run anywhere. 7.3.2. Advisory Placement If mandatory placement is about "must" and "must not", then advisory placement is the "I would prefer if" alternative. For constraints with scores greater than -INFINITY and less than INFINITY , the cluster will try to accommodate your wishes but may ignore them if the alternative is to stop some of the cluster resources. Advisory colocation constraints can combine with other elements of the configuration to behave as if they were mandatory. 7.3.3. Colocating Sets of Resources If your configuration requires that you create a set of resources that is colocated and started in order, you can configure a resource group that contains those resources, as described in Section 6.5, "Resource Groups" . There are some situations, however, where configuring the resources that need to be colocated as a resource group is not appropriate: You may need to colocate a set of resources but the resources do not necessarily need to start in order. You may have a resource C that must be colocated with either resource A or B has started but there is no relationship between A and B. You may have resources C and D that must be colocated with both resources A and B, but there is no relationship between A and B or between C and D. In these situations, you can create a colocation constraint on a set or sets of resources with the pcs constraint colocation set command. You can set the following options for a set of resources with the pcs constraint colocation set command. sequential , which can be set to true or false to indicate whether the members of the set must be colocated with each other. Setting sequential to false allows the members of this set to be colocated with another set listed later in the constraint, regardless of which members of this set are active. Therefore, this option makes sense only if another set is listed after this one in the constraint; otherwise, the constraint has no effect. role , which can be set to Stopped , Started , Master , or Slave . For information on multistate resources, see Section 9.2, "Multistate Resources: Resources That Have Multiple Modes" . You can set the following constraint options for a set of resources following the setoptions parameter of the pcs constraint colocation set command. kind , to indicate how to enforce the constraint. For information on this option, see Table 7.3, "Properties of an Order Constraint" . symmetrical , to indicate the order in which to stop the resources. If true, which is the default, stop the resources in the reverse order. Default value: true id , to provide a name for the constraint you are defining. When listing members of a set, each member is colocated with the one before it. For example, "set A B" means "B is colocated with A". However, when listing multiple sets, each set is colocated with the one after it. For example, "set C D sequential=false set A B" means "set C D (where C and D have no relation between each other) is colocated with set A B (where B is colocated with A)". The following command creates a colocation constraint on a set or sets of resources. 7.3.4. Removing Colocation Constraints Use the following command to remove colocation constraints with source_resource .	[ "pcs constraint colocation add [master\|slave] source_resource with [master\|slave] target_resource [ score ] [ options ]", "pcs constraint colocation add myresource1 with myresource2 score=INFINITY", "pcs constraint colocation add myresource1 with myresource2 score=-INFINITY", "pcs constraint colocation set resource1 resource2 [ resourceN ]... [ options ] [set resourceX resourceY ... [ options ]] [setoptions [ constraint_options ]]", "pcs constraint colocation remove source_resource target_resource" ]	https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/7/html/high_availability_add-on_reference/s1-colocationconstraints-haar
Chapter 3. Connecting to Knative with Kamelets	Chapter 3. Connecting to Knative with Kamelets You can connect Kamelets to Knative destinations (channels or brokers). Red Hat OpenShift Serverless is based on the open source Knative project , which provides portability and consistency across hybrid and multi-cloud environments by enabling an enterprise-grade serverless platform. OpenShift Serverless includes support for the Knative Eventing and Knative Serving components. Red Hat OpenShift Serverless, Knative Eventing, and Knative Serving enable you to use an event-driven architecture with serverless applications, decoupling the relationship between event producers and consumers by using a publish-subscribe or event-streaming model. Knative Eventing uses standard HTTP POST requests to send and receive events between event producers and consumers. These events conform to the CloudEvents specifications , which enables creating, parsing, sending, and receiving events in any programming language. You can use Kamelets to send CloudEvents to Knative and send them from Knative to event consumers. Kamelets can translate messages to CloudEvents and you can use them to apply any pre-processing and post-processing of the data within CloudEvents. 3.1. Overview of connecting to Knative with Kamelets If you use a Knative stream-processing framework, you can use Kamelets to connect services and applications to a Knative destination (channel or broker). Figure 3.1 illustrates the flow of connecting source and sink Kamelets to a Knative destination. Figure 3.1: Data flow with Kamelets and a Knative channel Here is an overview of the basic steps for using Kamelets and Kamelet Bindings to connect applications and services to a Knative destination: Set up Knative: Prepare your OpenShift cluster by installing the Camel K and OpenShift Serverless operators. Install the required Knative Serving and Eventing components. Create a Knative channel or broker. Determine which services or applications you want to connect to your Knative channel or broker. View the Kamelet Catalog to find the Kamelets for the source and sink components that you want to add to your integration. Also, determine the required configuration parameters for each Kamelet that you want to use. Create Kamelet Bindings: Create a Kamelet Binding that connects a source Kamelet to a Knative channel (or broker). Create a Kamelet Binding that connects the Knative channel (or broker) to a sink Kamelet. Optionally, manipulate the data that is passing between the Knative channel (or broker) and the data source or sink by adding one or more action Kamelets as intermediary steps within a Kamelet Binding. Optionally, define how to handle errors within a Kamelet Binding. Apply the Kamelet Bindings as resources to the project. The Camel K operator generates a separate Camel integration for each Kamelet Binding. When you configure a Kamelet Binding to use a Knative channel or a broker as the source of events, the Camel K operator materializes the corresponding integration as a Knative Serving service, to leverage the auto-scaling capabilities offered by Knative. 3.2. Setting up Knative Setting up Knative involves installing the required OpenShift operators and creating a Knative channel. 3.2.1. Preparing your OpenShift cluster To use Kamelets and OpenShift Serverless, install the following operators, components, and CLI tools: Red Hat Integration - Camel K operator and CLI tool - The operator installs and manages Camel K - a lightweight integration framework that runs natively in the cloud on OpenShift. The kamel CLI tool allows you to access all Camel K features. See the installation instructions in Installing Camel K . OpenShift Serverless operator - Provides a collection of APIs that enables containers, microservices, and functions to run "serverless". Serverless applications can scale up and down (to zero) on demand and be triggered by a number of event sources. When you install the OpenShift Serverless operator, it automatically creates the knative-serving namespace (for installing the Knative Serving component) and the knative-eventing namespace (required for installing the Knative Eventing component). Knative Eventing component Knative Serving component Knative CLI tool ( kn ) - Allows you to create Knative resources from the command line or from within Shell scripts. 3.2.1.1. Installing OpenShift Serverless You can install the OpenShift Serverless Operator on your OpenShift cluster from the OperatorHub. The OperatorHub is available from the OpenShift Container Platform web console and provides an interface for cluster administrators to discover and install Operators. The OpenShift Serverless Operator supports both Knative Serving and Knative Eventing features. For more details, see installing OpenShift Serverless Operator . Prerequisites You have cluster administrator access to an OpenShift project in which the Camel K Operator is installed. You installed the OpenShift CLI tool ( oc ) so that you can interact with the OpenShift cluster at the command line. For details on how to install the OpenShift CLI, see Installing the OpenShift CLI . Procedure In the OpenShift Container Platform web console, log in by using an account with cluster administrator privileges. In the left navigation menu, click Operators > OperatorHub . In the Filter by keyword text box, enter Serverless to find the OpenShift Serverless Operator . Read the information about the Operator and then click Install to display the Operator subscription page. Select the default subscription settings: Update Channel > Select the channel that matches your OpenShift version, for example, 4.14 Installation Mode > All namespaces on the cluster Approval Strategy > Automatic Note The Approval Strategy > Manual setting is also available if required by your environment. Click Install , and wait a few moments until the Operator is ready for use. Install the required Knative components using the steps in the OpenShift documentation: Installing Knative Serving Installing Knative Eventing (Optional) Download and install the OpenShift Serverless CLI tool: From the Help menu (?) at the top of the OpenShift web console, select Command line tools . Scroll down to the kn - OpenShift Serverless - Command Line Interface section. Click the link to download the binary for your local operating system (Linux, Mac, Windows) Unzip and install the CLI in your system path. To verify that you can access the kn CLI, open a command window and then type the following: kn --help This command shows information about OpenShift Serverless CLI commands. For more details, see the OpenShift Serverless CLI documentation . Additional resources Installing OpenShift Serverless in the OpenShift documentation 3.2.2. Creating a Knative channel A Knative channel is a custom resource that forwards events. After events have been sent to a channel from an event source or producer, these events can be sent to multiple Knative services, or other sinks, by using a subscription. This example uses an InMemoryChannel channel, which you use with OpenShift Serverless for development purposes. Note that InMemoryChannel type channels have the following limitations: No event persistence is available. If a pod goes down, events on that pod are lost. InMemoryChannel channels do not implement event ordering, so two events that are received in the channel at the same time can be delivered to a subscriber in any order. If a subscriber rejects an event, there are no re-delivery attempts by default. You can configure re-delivery attempts by modifying the delivery spec in the Subscription object. Prerequisites The OpenShift Serverless operator, Knative Eventing, and Knative Serving components are installed on your OpenShift Container Platform cluster. You have installed the OpenShift Serverless CLI ( kn ). You have created a project or have access to a project with the appropriate roles and permissions to create applications and other workloads in OpenShift Container Platform. Procedure Log in to your OpenShift cluster. Open the project in which you want to create your integration application. For example: oc project camel-k-knative Create a channel by using the Knative ( kn ) CLI command kn channel create <channel_name> --type <channel_type> For example, to create a channel named mychannel : kn channel create mychannel --type messaging.knative.dev:v1:InMemoryChannel To confirm that the channel now exists, type the following command to list all existing channels: kn channel list You should see your channel in the list. steps Connecting a data source to a Knative destination in a Kamelet Binding Connecting a Knative destination to a data sink in a Kamelet Binding 3.2.3. Creating a Knative broker A Knative broker is a custom resource that defines an event mesh for collecting a pool of CloudEvents. OpenShift Serverless provides a default Knative broker that you can create by using the kn CLI. You can use a broker in a Kamelet Binding, for example, when your application handles multiple event types and you do not want to create a channel for each event type. Prerequisites The OpenShift Serverless operator, Knative Eventing, and Knative Serving components are installed on your OpenShift Container Platform cluster. You have installed the OpenShift Serverless CLI ( kn ). You have created a project or have access to a project with the appropriate roles and permissions to create applications and other workloads in OpenShift Container Platform. Procedure Log in to your OpenShift cluster. Open the project in which you want to create your integration application. For example: oc project camel-k-knative Create the broker by using this Knative ( kn ) CLI command: kn broker create default To confirm that the broker now exists, type the following command to list all existing brokers: kn broker list You should see the default broker in the list. steps Connecting a data source to a Knative destination in a Kamelet Binding Connecting a Knative destination to a data sink in a Kamelet Binding 3.3. Connecting a data source to a Knative destination in a Kamelet Binding To connect a data source to a Knative destination (channel or broker), you create a Kamelet Binding as illustrated in Figure 3.2 . Figure 3.2 Connecting a data source to a Knative destination The Knative destination can be a Knative channel or a Knative broker. When you send data to a channel, there is only one event type for the channel. You do not need to specify any property values for the channel in a Kamelet Binding. When you send data to a broker, because the broker can handle more than one event type, you must specify a value for the type property when you reference the broker in a Kamelet Binding. Prerequisites You know the name and type of the Knative channel or broker to which you want to send events. The example in this procedure uses the InMemoryChannel channel named mychannel or the broker named default . For the broker example, the type property value is coffee for coffee events. You know which Kamelet you want to add to your Camel integration and the required instance parameters. The example Kamelet for this procedure is the coffee-source Kamelet. It has an optional parameter, period , that specifies how often to send each event. You can copy the code from Example source Kamelet to a file named coffee-source.kamelet.yaml file and then run the following command to add it as a resource to your namespace: oc apply -f coffee-source.kamelet.yaml Procedure To connect a data source to a Knative destination, create a Kamelet Binding: In an editor of your choice, create a YAML file with the following basic structure: Add a name for the Kamelet Binding. For this example, the name is coffees-to-knative because the binding connects the coffee-source Kamelet to a Knative destination. For the Kamelet Binding's source, specify a data source Kamelet (for example, the coffee-source Kamelet produces events that contain data about coffee) and configure any parameters for the Kamelet. For the Kamelet Binding's sink specify the Knative channel or broker and the required parameters. This example specifies a Knative channel as the sink: This example specifies a Knative broker as the sink: Save the YAML file (for example, coffees-to-knative.yaml ). Log into your OpenShift project. Add the Kamelet Binding as a resource to your OpenShift namespace: oc apply -f <kamelet binding filename> For example: oc apply -f coffees-to-knative.yaml The Camel K operator generates and runs a Camel K integration by using the KameletBinding resource. It might take a few minutes to build. To see the status of the KameletBinding : oc get kameletbindings To see the status of their integrations: oc get integrations To view the integration's log: kamel logs <integration> -n <project> For example: kamel logs coffees-to-knative -n my-camel-knative steps Connecting a Knative destination to a data sink in a Kamelet Binding See also Applying operations to data within a connection Handling errors within a connection 3.4. Connecting a Knative destination to a data sink in a Kamelet Binding To connect a Knative destination to a data sink, you create a Kamelet Binding as illustrated in Figure 3.3 . Figure 3.3 Connecting a Knative destination to a data sink The Knative destination can be a Knative channel or a Knative broker. When you send data from a channel, there is only one event type for the channel. You do not need to specify any property values for the channel in a Kamelet Binding. When you send data from a broker, because the broker can handle more than one event type, you must specify a value for the type property when you reference the broker in a Kamelet Binding. Prerequisites You know the name and type of the Knative channel or the name of the broker from which you want to receive events. For a broker, you also know the type of events that you want to receive. The example in this procedure uses the InMemoryChannel channel named mychannel or the broker named mybroker and coffee events (for the type property). These are the same example destinations that are used to receive events from the coffee source in Connecting a data source to a Knative channel in a Kamelet Binding . You know which Kamelet you want to add to your Camel integration and the required instance parameters. The example Kamelet for this procedure is the log-sink Kamelet that is provided in the Kamelet Catalog and is useful for testing and debugging. The showStreams parameter specified to show the message body of the data. Procedure To connect a Knative channel to a data sink, create a Kamelet Binding: In an editor of your choice, create a YAML file with the following basic structure: Add a name for the Kamelet Binding. For this example, the name is knative-to-log because the binding connects the Knative destination to the log-sink Kamelet. For the Kamelet Binding's source, specify the Knative channel or broker and the required parameters. This example specifies a Knative channel as the source: This example specifies a Knative broker as the source: For the Kamelet Binding's sink, specify the data consumer Kamelet (for example, the log-sink Kamelet) and configure any parameters for the Kamelet, for example: Save the YAML file (for example, knative-to-log.yaml ). Log into your OpenShift project. Add the Kamelet Binding as a resource to your OpenShift namespace: oc apply -f <kamelet binding filename> For example: oc apply -f knative-to-log.yaml The Camel K operator generates and runs a Camel K integration by using the KameletBinding resource. It might take a few minutes to build. To see the status of the KameletBinding : oc get kameletbindings To see the status of the integration: oc get integrations To view the integration's log: kamel logs <integration> -n <project> For example: kamel logs knative-to-log -n my-camel-knative In the output, you should see coffee events, for example: To stop a running integration, delete the associated Kamelet Binding resource: oc delete kameletbindings/<kameletbinding-name> For example: oc delete kameletbindings/knative-to-log See also Applying operations to data within a connection Handling errors within a connection	[ "apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: spec: source: sink:", "apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: coffees-to-knative spec: source: sink:", "apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: coffees-to-knative spec: source: ref: kind: Kamelet apiVersion: camel.apache.org/v1alpha1 name: coffee-source properties: period: 5000 sink:", "apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: coffees-to-knative spec: source: ref: kind: Kamelet apiVersion: camel.apache.org/v1alpha1 name: coffee-source properties: period: 5000 sink: ref: apiVersion: messaging.knative.dev/v1 kind: InMemoryChannel name: mychannel", "apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: coffees-to-knative spec: source: ref: kind: Kamelet apiVersion: camel.apache.org/v1alpha1 name: coffee-source properties: period: 5000 sink: ref: kind: Broker apiVersion: eventing.knative.dev/v1 name: default properties: type: coffee", "apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: spec: source: sink:", "apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: knative-to-log spec: source: sink:", "apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: knative-to-log spec: source: ref: apiVersion: messaging.knative.dev/v1 kind: InMemoryChannel name: mychannel sink:", "apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: knative-to-log spec: source: ref: kind: Broker apiVersion: eventing.knative.dev/v1 name: default properties: type: coffee sink:", "apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: knative-to-log spec: source: ref: apiVersion: messaging.knative.dev/v1 kind: InMemoryChannel name: mychannel sink: ref: apiVersion: camel.apache.org/v1alpha1 kind: Kamelet name: log-sink properties: showStreams: true", "[1] INFO [sink] (vert.x-worker-thread-1) {\"id\":254,\"uid\":\"8e180ef7-8924-4fc7-ab81-d6058618cc42\",\"blend_name\":\"Good-morning Star\",\"origin\":\"Santander, Colombia\",\"variety\":\"Kaffa\",\"notes\":\"delicate, creamy, lemongrass, granola, soil\",\"intensifier\":\"sharp\"} [1] INFO [sink] (vert.x-worker-thread-2) {\"id\":8169,\"uid\":\"3733c3a5-4ad9-43a3-9acc-d4cd43de6f3d\",\"blend_name\":\"Caf? Java\",\"origin\":\"Nayarit, Mexico\",\"variety\":\"Red Bourbon\",\"notes\":\"unbalanced, full, granola, bittersweet chocolate, nougat\",\"intensifier\":\"delicate\"}" ]	https://docs.redhat.com/en/documentation/red_hat_build_of_apache_camel_k/1.10.7/html/integrating_applications_with_kamelets/connecting-to-knative-kamelets
Chapter 72. KafkaClientAuthenticationScramSha256 schema reference	Chapter 72. KafkaClientAuthenticationScramSha256 schema reference Used in: KafkaBridgeSpec , KafkaConnectSpec , KafkaMirrorMaker2ClusterSpec , KafkaMirrorMakerConsumerSpec , KafkaMirrorMakerProducerSpec Full list of KafkaClientAuthenticationScramSha256 schema properties To configure SASL-based SCRAM-SHA-256 authentication, set the type property to scram-sha-256 . The SCRAM-SHA-256 authentication mechanism requires a username and password. 72.1. username Specify the username in the username property. 72.2. passwordSecret In the passwordSecret property, specify a link to a Secret containing the password. You can use the secrets created by the User Operator. If required, you can create a text file that contains the password, in cleartext, to use for authentication: echo -n PASSWORD > MY-PASSWORD .txt You can then create a Secret from the text file, setting your own field name (key) for the password: oc create secret generic MY-CONNECT-SECRET-NAME --from-file= MY-PASSWORD-FIELD-NAME =./ MY-PASSWORD .txt Example Secret for SCRAM-SHA-256 client authentication for Kafka Connect apiVersion: v1 kind: Secret metadata: name: my-connect-secret-name type: Opaque data: my-connect-password-field: LFTIyFRFlMmU2N2Tm The secretName property contains the name of the Secret , and the password property contains the name of the key under which the password is stored inside the Secret . Important Do not specify the actual password in the password property. Example SASL-based SCRAM-SHA-256 client authentication configuration for Kafka Connect authentication: type: scram-sha-256 username: my-connect-username passwordSecret: secretName: my-connect-secret-name password: my-connect-password-field 72.3. KafkaClientAuthenticationScramSha256 schema properties Property Description passwordSecret Reference to the Secret which holds the password. PasswordSecretSource type Must be scram-sha-256 . string username Username used for the authentication. string	[ "echo -n PASSWORD > MY-PASSWORD .txt", "create secret generic MY-CONNECT-SECRET-NAME --from-file= MY-PASSWORD-FIELD-NAME =./ MY-PASSWORD .txt", "apiVersion: v1 kind: Secret metadata: name: my-connect-secret-name type: Opaque data: my-connect-password-field: LFTIyFRFlMmU2N2Tm", "authentication: type: scram-sha-256 username: my-connect-username passwordSecret: secretName: my-connect-secret-name password: my-connect-password-field" ]	https://docs.redhat.com/en/documentation/red_hat_streams_for_apache_kafka/2.5/html/amq_streams_api_reference/type-KafkaClientAuthenticationScramSha256-reference
Chapter 14. Interoperability	Chapter 14. Interoperability This chapter discusses how to use AMQ C++ in combination with other AMQ components. For an overview of the compatibility of AMQ components, see the product introduction . 14.1. Interoperating with other AMQP clients AMQP messages are composed using the AMQP type system . This common format is one of the reasons AMQP clients in different languages are able to interoperate with each other. When sending messages, AMQ C++ automatically converts language-native types to AMQP-encoded data. When receiving messages, the reverse conversion takes place. Note More information about AMQP types is available at the interactive type reference maintained by the Apache Qpid project. Table 14.1. AMQP types AMQP type Description null An empty value boolean A true or false value char A single Unicode character string A sequence of Unicode characters binary A sequence of bytes byte A signed 8-bit integer short A signed 16-bit integer int A signed 32-bit integer long A signed 64-bit integer ubyte An unsigned 8-bit integer ushort An unsigned 16-bit integer uint An unsigned 32-bit integer ulong An unsigned 64-bit integer float A 32-bit floating point number double A 64-bit floating point number array A sequence of values of a single type list A sequence of values of variable type map A mapping from distinct keys to values uuid A universally unique identifier symbol A 7-bit ASCII string from a constrained domain timestamp An absolute point in time Table 14.2. AMQ C++ types before encoding and after decoding AMQP type AMQ C++ type before encoding AMQ C++ type after decoding null nullptr nullptr boolean bool bool char wchar_t wchar_t string std::string std::string binary proton::binary proton::binary byte int8_t int8_t short int16_t int16_t int int32_t int32_t long int64_t int64_t ubyte uint8_t uint8_t ushort uint16_t uint16_t uint uint32_t uint32_t ulong uint64_t uint64_t float float float double double double list std::vector std::vector map std::map std::map uuid proton::uuid proton::uuid symbol proton::symbol proton::symbol timestamp proton::timestamp proton::timestamp Table 14.3. AMQ C++ and other AMQ client types (1 of 2) AMQ C++ type before encoding AMQ JavaScript type AMQ .NET type nullptr null null bool boolean System.Boolean wchar_t number System.Char std::string string System.String proton::binary string System.Byte[] int8_t number System.SByte int16_t number System.Int16 int32_t number System.Int32 int64_t number System.Int64 uint8_t number System.Byte uint16_t number System.UInt16 uint32_t number System.UInt32 uint64_t number System.UInt64 float number System.Single double number System.Double std::vector Array Amqp.List std::map object Amqp.Map proton::uuid number System.Guid proton::symbol string Amqp.Symbol proton::timestamp number System.DateTime Table 14.4. AMQ C++ and other AMQ client types (2 of 2) AMQ C++ type before encoding AMQ Python type AMQ Ruby type nullptr None nil bool bool true, false wchar_t unicode String std::string unicode String proton::binary bytes String int8_t int Integer int16_t int Integer int32_t long Integer int64_t long Integer uint8_t long Integer uint16_t long Integer uint32_t long Integer uint64_t long Integer float float Float double float Float std::vector list Array std::map dict Hash proton::uuid - - proton::symbol str Symbol proton::timestamp long Time 14.2. Interoperating with AMQ JMS AMQP defines a standard mapping to the JMS messaging model. This section discusses the various aspects of that mapping. For more information, see the AMQ JMS Interoperability chapter. JMS message types AMQ C++ provides a single message type whose body type can vary. By contrast, the JMS API uses different message types to represent different kinds of data. The table below indicates how particular body types map to JMS message types. For more explicit control of the resulting JMS message type, you can set the x-opt-jms-msg-type message annotation. See the AMQ JMS Interoperability chapter for more information. Table 14.5. AMQ C++ and JMS message types AMQ C++ body type JMS message type std::string TextMessage nullptr TextMessage proton::binary BytesMessage Any other type ObjectMessage 14.3. Connecting to AMQ Broker AMQ Broker is designed to interoperate with AMQP 1.0 clients. Check the following to ensure the broker is configured for AMQP messaging: Port 5672 in the network firewall is open. The AMQ Broker AMQP acceptor is enabled. See Default acceptor settings . The necessary addresses are configured on the broker. See Addresses, Queues, and Topics . The broker is configured to permit access from your client, and the client is configured to send the required credentials. See Broker Security . 14.4. Connecting to AMQ Interconnect AMQ Interconnect works with any AMQP 1.0 client. Check the following to ensure the components are configured correctly: Port 5672 in the network firewall is open. The router is configured to permit access from your client, and the client is configured to send the required credentials. See Securing network connections .	null	https://docs.redhat.com/en/documentation/red_hat_amq/2020.q4/html/using_the_amq_cpp_client/interoperability
Chapter 5. Installing a cluster on Azure with customizations	Chapter 5. Installing a cluster on Azure with customizations In OpenShift Container Platform version 4.16, you can install a customized cluster on infrastructure that the installation program provisions on Microsoft Azure. To customize the installation, you modify parameters in the install-config.yaml file before you install the cluster. 5.1. Prerequisites You reviewed details about the OpenShift Container Platform installation and update processes. You read the documentation on selecting a cluster installation method and preparing it for users . You configured an Azure account to host the cluster and determined the tested and validated region to deploy the cluster to. If you use a firewall, you configured it to allow the sites that your cluster requires access to. If you use customer-managed encryption keys, you prepared your Azure environment for encryption . 5.2. Internet access for OpenShift Container Platform In OpenShift Container Platform 4.16, you require access to the internet to install your cluster. You must have internet access to: Access OpenShift Cluster Manager to download the installation program and perform subscription management. If the cluster has internet access and you do not disable Telemetry, that service automatically entitles your cluster. Access Quay.io to obtain the packages that are required to install your cluster. Obtain the packages that are required to perform cluster updates. Important If your cluster cannot have direct internet access, you can perform a restricted network installation on some types of infrastructure that you provision. During that process, you download the required content and use it to populate a mirror registry with the installation packages. With some installation types, the environment that you install your cluster in will not require internet access. Before you update the cluster, you update the content of the mirror registry. 5.3. Generating a key pair for cluster node SSH access During an OpenShift Container Platform installation, you can provide an SSH public key to the installation program. The key is passed to the Red Hat Enterprise Linux CoreOS (RHCOS) nodes through their Ignition config files and is used to authenticate SSH access to the nodes. The key is added to the ~/.ssh/authorized_keys list for the core user on each node, which enables password-less authentication. After the key is passed to the nodes, you can use the key pair to SSH in to the RHCOS nodes as the user core . To access the nodes through SSH, the private key identity must be managed by SSH for your local user. If you want to SSH in to your cluster nodes to perform installation debugging or disaster recovery, you must provide the SSH public key during the installation process. The ./openshift-install gather command also requires the SSH public key to be in place on the cluster nodes. Important Do not skip this procedure in production environments, where disaster recovery and debugging is required. Note You must use a local key, not one that you configured with platform-specific approaches such as AWS key pairs . Procedure If you do not have an existing SSH key pair on your local machine to use for authentication onto your cluster nodes, create one. For example, on a computer that uses a Linux operating system, run the following command: USD ssh-keygen -t ed25519 -N '' -f <path>/<file_name> 1 1 Specify the path and file name, such as ~/.ssh/id_ed25519 , of the new SSH key. If you have an existing key pair, ensure your public key is in the your ~/.ssh directory. Note If you plan to install an OpenShift Container Platform cluster that uses the RHEL cryptographic libraries that have been submitted to NIST for FIPS 140-2/140-3 Validation on only the x86_64 , ppc64le , and s390x architectures, do not create a key that uses the ed25519 algorithm. Instead, create a key that uses the rsa or ecdsa algorithm. View the public SSH key: USD cat <path>/<file_name>.pub For example, run the following to view the ~/.ssh/id_ed25519.pub public key: USD cat ~/.ssh/id_ed25519.pub Add the SSH private key identity to the SSH agent for your local user, if it has not already been added. SSH agent management of the key is required for password-less SSH authentication onto your cluster nodes, or if you want to use the ./openshift-install gather command. Note On some distributions, default SSH private key identities such as ~/.ssh/id_rsa and ~/.ssh/id_dsa are managed automatically. If the ssh-agent process is not already running for your local user, start it as a background task: USD eval "USD(ssh-agent -s)" Example output Agent pid 31874 Note If your cluster is in FIPS mode, only use FIPS-compliant algorithms to generate the SSH key. The key must be either RSA or ECDSA. Add your SSH private key to the ssh-agent : USD ssh-add <path>/<file_name> 1 1 Specify the path and file name for your SSH private key, such as ~/.ssh/id_ed25519 Example output Identity added: /home/<you>/<path>/<file_name> (<computer_name>) steps When you install OpenShift Container Platform, provide the SSH public key to the installation program. 5.4. Using the Azure Marketplace offering Using the Azure Marketplace offering lets you deploy an OpenShift Container Platform cluster, which is billed on pay-per-use basis (hourly, per core) through Azure, while still being supported directly by Red Hat. To deploy an OpenShift Container Platform cluster using the Azure Marketplace offering, you must first obtain the Azure Marketplace image. The installation program uses this image to deploy worker or control plane nodes. When obtaining your image, consider the following: While the images are the same, the Azure Marketplace publisher is different depending on your region. If you are located in North America, specify redhat as the publisher. If you are located in EMEA, specify redhat-limited as the publisher. The offer includes a rh-ocp-worker SKU and a rh-ocp-worker-gen1 SKU. The rh-ocp-worker SKU represents a Hyper-V generation version 2 VM image. The default instance types used in OpenShift Container Platform are version 2 compatible. If you plan to use an instance type that is only version 1 compatible, use the image associated with the rh-ocp-worker-gen1 SKU. The rh-ocp-worker-gen1 SKU represents a Hyper-V version 1 VM image. Important Installing images with the Azure marketplace is not supported on clusters with 64-bit ARM instances. Prerequisites You have installed the Azure CLI client (az) . Your Azure account is entitled for the offer and you have logged into this account with the Azure CLI client. Procedure Display all of the available OpenShift Container Platform images by running one of the following commands: North America: USD az vm image list --all --offer rh-ocp-worker --publisher redhat -o table Example output Offer Publisher Sku Urn Version ------------- -------------- ------------------ -------------------------------------------------------------- ----------------- rh-ocp-worker RedHat rh-ocp-worker RedHat:rh-ocp-worker:rh-ocp-worker:4.15.2024072409 4.15.2024072409 rh-ocp-worker RedHat rh-ocp-worker-gen1 RedHat:rh-ocp-worker:rh-ocp-worker-gen1:4.15.2024072409 4.15.2024072409 EMEA: USD az vm image list --all --offer rh-ocp-worker --publisher redhat-limited -o table Example output Offer Publisher Sku Urn Version ------------- -------------- ------------------ -------------------------------------------------------------- ----------------- rh-ocp-worker redhat-limited rh-ocp-worker redhat-limited:rh-ocp-worker:rh-ocp-worker:4.15.2024072409 4.15.2024072409 rh-ocp-worker redhat-limited rh-ocp-worker-gen1 redhat-limited:rh-ocp-worker:rh-ocp-worker-gen1:4.15.2024072409 4.15.2024072409 Note Use the latest image that is available for compute and control plane nodes. If required, your VMs are automatically upgraded as part of the installation process. Inspect the image for your offer by running one of the following commands: North America: USD az vm image show --urn redhat:rh-ocp-worker:rh-ocp-worker:<version> EMEA: USD az vm image show --urn redhat-limited:rh-ocp-worker:rh-ocp-worker:<version> Review the terms of the offer by running one of the following commands: North America: USD az vm image terms show --urn redhat:rh-ocp-worker:rh-ocp-worker:<version> EMEA: USD az vm image terms show --urn redhat-limited:rh-ocp-worker:rh-ocp-worker:<version> Accept the terms of the offering by running one of the following commands: North America: USD az vm image terms accept --urn redhat:rh-ocp-worker:rh-ocp-worker:<version> EMEA: USD az vm image terms accept --urn redhat-limited:rh-ocp-worker:rh-ocp-worker:<version> Record the image details of your offer. You must update the compute section in the install-config.yaml file with values for publisher , offer , sku , and version before deploying the cluster. You may also update the controlPlane section to deploy control plane machines with the specified image details, or the defaultMachinePlatform section to deploy both control plane and compute machines with the specified image details. Use the latest available image for control plane and compute nodes. Sample install-config.yaml file with the Azure Marketplace compute nodes apiVersion: v1 baseDomain: example.com compute: - hyperthreading: Enabled name: worker platform: azure: type: Standard_D4s_v5 osImage: publisher: redhat offer: rh-ocp-worker sku: rh-ocp-worker version: 413.92.2023101700 replicas: 3 5.5. Obtaining the installation program Before you install OpenShift Container Platform, download the installation file on the host you are using for installation. Prerequisites You have a computer that runs Linux or macOS, with at least 1.2 GB of local disk space. Procedure Go to the Cluster Type page on the Red Hat Hybrid Cloud Console. If you have a Red Hat account, log in with your credentials. If you do not, create an account. Tip You can also download the binaries for a specific OpenShift Container Platform release . Select your infrastructure provider from the Run it yourself section of the page. Select your host operating system and architecture from the dropdown menus under OpenShift Installer and click Download Installer . Place the downloaded file in the directory where you want to store the installation configuration files. Important The installation program creates several files on the computer that you use to install your cluster. You must keep the installation program and the files that the installation program creates after you finish installing the cluster. Both of the files are required to delete the cluster. Deleting the files created by the installation program does not remove your cluster, even if the cluster failed during installation. To remove your cluster, complete the OpenShift Container Platform uninstallation procedures for your specific cloud provider. Extract the installation program. For example, on a computer that uses a Linux operating system, run the following command: USD tar -xvf openshift-install-linux.tar.gz Download your installation pull secret from Red Hat OpenShift Cluster Manager . This pull secret allows you to authenticate with the services that are provided by the included authorities, including Quay.io, which serves the container images for OpenShift Container Platform components. Tip Alternatively, you can retrieve the installation program from the Red Hat Customer Portal , where you can specify a version of the installation program to download. However, you must have an active subscription to access this page. 5.6. Creating the installation configuration file You can customize the OpenShift Container Platform cluster you install on Microsoft Azure. Prerequisites You have the OpenShift Container Platform installation program and the pull secret for your cluster. You have an Azure subscription ID and tenant ID. If you are installing the cluster using a service principal, you have its application ID and password. If you are installing the cluster using a system-assigned managed identity, you have enabled it on the virtual machine that you will run the installation program from. If you are installing the cluster using a user-assigned managed identity, you have met these prerequisites: You have its client ID. You have assigned it to the virtual machine that you will run the installation program from. Procedure Optional: If you have run the installation program on this computer before, and want to use an alternative service principal or managed identity, go to the ~/.azure/ directory and delete the osServicePrincipal.json configuration file. Deleting this file prevents the installation program from automatically reusing subscription and authentication values from a installation. Create the install-config.yaml file. Change to the directory that contains the installation program and run the following command: USD ./openshift-install create install-config --dir <installation_directory> 1 1 For <installation_directory> , specify the directory name to store the files that the installation program creates. When specifying the directory: Verify that the directory has the execute permission. This permission is required to run Terraform binaries under the installation directory. Use an empty directory. Some installation assets, such as bootstrap X.509 certificates, have short expiration intervals, therefore you must not reuse an installation directory. If you want to reuse individual files from another cluster installation, you can copy them into your directory. However, the file names for the installation assets might change between releases. Use caution when copying installation files from an earlier OpenShift Container Platform version. At the prompts, provide the configuration details for your cloud: Optional: Select an SSH key to use to access your cluster machines. Note For production OpenShift Container Platform clusters on which you want to perform installation debugging or disaster recovery, specify an SSH key that your ssh-agent process uses. Select azure as the platform to target. If the installation program cannot locate the osServicePrincipal.json configuration file from a installation, you are prompted for Azure subscription and authentication values. Enter the following Azure parameter values for your subscription: azure subscription id : Enter the subscription ID to use for the cluster. azure tenant id : Enter the tenant ID. Depending on the Azure identity you are using to deploy the cluster, do one of the following when prompted for the azure service principal client id : If you are using a service principal, enter its application ID. If you are using a system-assigned managed identity, leave this value blank. If you are using a user-assigned managed identity, specify its client ID. Depending on the Azure identity you are using to deploy the cluster, do one of the following when prompted for the azure service principal client secret : If you are using a service principal, enter its password. If you are using a system-assigned managed identity, leave this value blank. If you are using a user-assigned managed identity, leave this value blank. Select the region to deploy the cluster to. Select the base domain to deploy the cluster to. The base domain corresponds to the Azure DNS Zone that you created for your cluster. Enter a descriptive name for your cluster. Important All Azure resources that are available through public endpoints are subject to resource name restrictions, and you cannot create resources that use certain terms. For a list of terms that Azure restricts, see Resolve reserved resource name errors in the Azure documentation. Modify the install-config.yaml file. You can find more information about the available parameters in the "Installation configuration parameters" section. Note If you are installing a three-node cluster, be sure to set the compute.replicas parameter to 0 . This ensures that the cluster's control planes are schedulable. For more information, see "Installing a three-node cluster on Azure". Back up the install-config.yaml file so that you can use it to install multiple clusters. Important The install-config.yaml file is consumed during the installation process. If you want to reuse the file, you must back it up now. If previously not detected, the installation program creates an osServicePrincipal.json configuration file and stores this file in the ~/.azure/ directory on your computer. This ensures that the installation program can load the profile when it is creating an OpenShift Container Platform cluster on the target platform. Additional resources Installation configuration parameters for Azure 5.6.1. Minimum resource requirements for cluster installation Each cluster machine must meet the following minimum requirements: Table 5.1. Minimum resource requirements Machine Operating System vCPU [1] Virtual RAM Storage Input/Output Per Second (IOPS) [2] Bootstrap RHCOS 4 16 GB 100 GB 300 Control plane RHCOS 4 16 GB 100 GB 300 Compute RHCOS, RHEL 8.6 and later [3] 2 8 GB 100 GB 300 One vCPU is equivalent to one physical core when simultaneous multithreading (SMT), or Hyper-Threading, is not enabled. When enabled, use the following formula to calculate the corresponding ratio: (threads per core x cores) x sockets = vCPUs. OpenShift Container Platform and Kubernetes are sensitive to disk performance, and faster storage is recommended, particularly for etcd on the control plane nodes which require a 10 ms p99 fsync duration. Note that on many cloud platforms, storage size and IOPS scale together, so you might need to over-allocate storage volume to obtain sufficient performance. As with all user-provisioned installations, if you choose to use RHEL compute machines in your cluster, you take responsibility for all operating system life cycle management and maintenance, including performing system updates, applying patches, and completing all other required tasks. Use of RHEL 7 compute machines is deprecated and has been removed in OpenShift Container Platform 4.10 and later. Note As of OpenShift Container Platform version 4.13, RHCOS is based on RHEL version 9.2, which updates the micro-architecture requirements. The following list contains the minimum instruction set architectures (ISA) that each architecture requires: x86-64 architecture requires x86-64-v2 ISA ARM64 architecture requires ARMv8.0-A ISA IBM Power architecture requires Power 9 ISA s390x architecture requires z14 ISA For more information, see Architectures (RHEL documentation). Important You are required to use Azure virtual machines that have the premiumIO parameter set to true . If an instance type for your platform meets the minimum requirements for cluster machines, it is supported to use in OpenShift Container Platform. Additional resources Optimizing storage 5.6.2. Tested instance types for Azure The following Microsoft Azure instance types have been tested with OpenShift Container Platform. Example 5.1. Machine types based on 64-bit x86 architecture standardBSFamily standardBsv2Family standardDADSv5Family standardDASv4Family standardDASv5Family standardDCACCV5Family standardDCADCCV5Family standardDCADSv5Family standardDCASv5Family standardDCSv3Family standardDCSv2Family standardDDCSv3Family standardDDSv4Family standardDDSv5Family standardDLDSv5Family standardDLSv5Family standardDSFamily standardDSv2Family standardDSv2PromoFamily standardDSv3Family standardDSv4Family standardDSv5Family standardEADSv5Family standardEASv4Family standardEASv5Family standardEBDSv5Family standardEBSv5Family standardECACCV5Family standardECADCCV5Family standardECADSv5Family standardECASv5Family standardEDSv4Family standardEDSv5Family standardEIADSv5Family standardEIASv4Family standardEIASv5Family standardEIBDSv5Family standardEIBSv5Family standardEIDSv5Family standardEISv3Family standardEISv5Family standardESv3Family standardESv4Family standardESv5Family standardFXMDVSFamily standardFSFamily standardFSv2Family standardGSFamily standardHBrsv2Family standardHBSFamily standardHBv4Family standardHCSFamily standardHXFamily standardLASv3Family standardLSFamily standardLSv2Family standardLSv3Family standardMDSMediumMemoryv2Family standardMDSMediumMemoryv3Family standardMIDSMediumMemoryv2Family standardMISMediumMemoryv2Family standardMSFamily standardMSMediumMemoryv2Family standardMSMediumMemoryv3Family StandardNCADSA100v4Family Standard NCASv3_T4 Family standardNCSv3Family standardNDSv2Family standardNPSFamily StandardNVADSA10v5Family standardNVSv3Family standardXEISv4Family 5.6.3. Tested instance types for Azure on 64-bit ARM infrastructures The following Microsoft Azure ARM64 instance types have been tested with OpenShift Container Platform. Example 5.2. Machine types based on 64-bit ARM architecture standardBpsv2Family standardDPSv5Family standardDPDSv5Family standardDPLDSv5Family standardDPLSv5Family standardEPSv5Family standardEPDSv5Family 5.6.4. Enabling trusted launch for Azure VMs You can enable two trusted launch features when installing your cluster on Azure: secure boot and virtualized Trusted Platform Modules . See the Azure documentation about virtual machine sizes to learn what sizes of virtual machines support these features. Important Trusted launch is a Technology Preview feature only. Technology Preview features are not supported with Red Hat production service level agreements (SLAs) and might not be functionally complete. Red Hat does not recommend using them in production. These features provide early access to upcoming product features, enabling customers to test functionality and provide feedback during the development process. For more information about the support scope of Red Hat Technology Preview features, see Technology Preview Features Support Scope . Prerequisites You have created an install-config.yaml file. Procedure Use a text editor to edit the install-config.yaml file prior to deploying your cluster and add the following stanza: controlPlane: 1 platform: azure: settings: securityType: TrustedLaunch 2 trustedLaunch: uefiSettings: secureBoot: Enabled 3 virtualizedTrustedPlatformModule: Enabled 4 1 Specify controlPlane.platform.azure or compute.platform.azure to enable trusted launch on only control plane or compute nodes respectively. Specify platform.azure.defaultMachinePlatform to enable trusted launch on all nodes. 2 Enable trusted launch features. 3 Enable secure boot. For more information, see the Azure documentation about secure boot . 4 Enable the virtualized Trusted Platform Module. For more information, see the Azure documentation about virtualized Trusted Platform Modules . 5.6.5. Enabling confidential VMs You can enable confidential VMs when installing your cluster. You can enable confidential VMs for compute nodes, control plane nodes, or all nodes. Important Using confidential VMs is a Technology Preview feature only. Technology Preview features are not supported with Red Hat production service level agreements (SLAs) and might not be functionally complete. Red Hat does not recommend using them in production. These features provide early access to upcoming product features, enabling customers to test functionality and provide feedback during the development process. For more information about the support scope of Red Hat Technology Preview features, see Technology Preview Features Support Scope . You can use confidential VMs with the following VM sizes: DCasv5-series DCadsv5-series ECasv5-series ECadsv5-series Important Confidential VMs are currently not supported on 64-bit ARM architectures. Prerequisites You have created an install-config.yaml file. Procedure Use a text editor to edit the install-config.yaml file prior to deploying your cluster and add the following stanza: controlPlane: 1 platform: azure: settings: securityType: ConfidentialVM 2 confidentialVM: uefiSettings: secureBoot: Enabled 3 virtualizedTrustedPlatformModule: Enabled 4 osDisk: securityProfile: securityEncryptionType: VMGuestStateOnly 5 1 Specify controlPlane.platform.azure or compute.platform.azure to deploy confidential VMs on only control plane or compute nodes respectively. Specify platform.azure.defaultMachinePlatform to deploy confidential VMs on all nodes. 2 Enable confidential VMs. 3 Enable secure boot. For more information, see the Azure documentation about secure boot . 4 Enable the virtualized Trusted Platform Module. For more information, see the Azure documentation about virtualized Trusted Platform Modules . 5 Specify VMGuestStateOnly to encrypt the VM guest state. 5.6.6. Sample customized install-config.yaml file for Azure You can customize the install-config.yaml file to specify more details about your OpenShift Container Platform cluster's platform or modify the values of the required parameters. Important This sample YAML file is provided for reference only. You must obtain your install-config.yaml file by using the installation program and modify it. apiVersion: v1 baseDomain: example.com 1 controlPlane: 2 hyperthreading: Enabled 3 4 name: master platform: azure: encryptionAtHost: true ultraSSDCapability: Enabled osDisk: diskSizeGB: 1024 5 diskType: Premium_LRS diskEncryptionSet: resourceGroup: disk_encryption_set_resource_group name: disk_encryption_set_name subscriptionId: secondary_subscription_id osImage: publisher: example_publisher_name offer: example_image_offer sku: example_offer_sku version: example_image_version type: Standard_D8s_v3 replicas: 3 compute: 6 - hyperthreading: Enabled 7 name: worker platform: azure: ultraSSDCapability: Enabled type: Standard_D2s_v3 encryptionAtHost: true osDisk: diskSizeGB: 512 8 diskType: Standard_LRS diskEncryptionSet: resourceGroup: disk_encryption_set_resource_group name: disk_encryption_set_name subscriptionId: secondary_subscription_id osImage: publisher: example_publisher_name offer: example_image_offer sku: example_offer_sku version: example_image_version zones: 9 - "1" - "2" - "3" replicas: 5 metadata: name: test-cluster 10 networking: clusterNetwork: - cidr: 10.128.0.0/14 hostPrefix: 23 machineNetwork: - cidr: 10.0.0.0/16 networkType: OVNKubernetes 11 serviceNetwork: - 172.30.0.0/16 platform: azure: defaultMachinePlatform: osImage: 12 publisher: example_publisher_name offer: example_image_offer sku: example_offer_sku version: example_image_version ultraSSDCapability: Enabled baseDomainResourceGroupName: resource_group 13 region: centralus 14 resourceGroupName: existing_resource_group 15 outboundType: Loadbalancer cloudName: AzurePublicCloud pullSecret: '{"auths": ...}' 16 fips: false 17 sshKey: ssh-ed25519 AAAA... 18 1 10 14 16 Required. The installation program prompts you for this value. 2 6 If you do not provide these parameters and values, the installation program provides the default value. 3 7 The controlPlane section is a single mapping, but the compute section is a sequence of mappings. To meet the requirements of the different data structures, the first line of the compute section must begin with a hyphen, - , and the first line of the controlPlane section must not. Only one control plane pool is used. 4 Whether to enable or disable simultaneous multithreading, or hyperthreading . By default, simultaneous multithreading is enabled to increase the performance of your machines' cores. You can disable it by setting the parameter value to Disabled . If you disable simultaneous multithreading in some cluster machines, you must disable it in all cluster machines. Important If you disable simultaneous multithreading, ensure that your capacity planning accounts for the dramatically decreased machine performance. Use larger virtual machine types, such as Standard_D8s_v3 , for your machines if you disable simultaneous multithreading. 5 8 You can specify the size of the disk to use in GB. Minimum recommendation for control plane nodes is 1024 GB. 9 Specify a list of zones to deploy your machines to. For high availability, specify at least two zones. 11 The cluster network plugin to install. The default value OVNKubernetes is the only supported value. 12 Optional: A custom Red Hat Enterprise Linux CoreOS (RHCOS) image that should be used to boot control plane and compute machines. The publisher , offer , sku , and version parameters under platform.azure.defaultMachinePlatform.osImage apply to both control plane and compute machines. If the parameters under controlPlane.platform.azure.osImage or compute.platform.azure.osImage are set, they override the platform.azure.defaultMachinePlatform.osImage parameters. 13 Specify the name of the resource group that contains the DNS zone for your base domain. 15 Specify the name of an already existing resource group to install your cluster to. If undefined, a new resource group is created for the cluster. 17 Whether to enable or disable FIPS mode. By default, FIPS mode is not enabled. If FIPS mode is enabled, the Red Hat Enterprise Linux CoreOS (RHCOS) machines that OpenShift Container Platform runs on bypass the default Kubernetes cryptography suite and use the cryptography modules that are provided with RHCOS instead. Important To enable FIPS mode for your cluster, you must run the installation program from a Red Hat Enterprise Linux (RHEL) computer configured to operate in FIPS mode. For more information about configuring FIPS mode on RHEL, see Switching RHEL to FIPS mode . When running Red Hat Enterprise Linux (RHEL) or Red Hat Enterprise Linux CoreOS (RHCOS) booted in FIPS mode, OpenShift Container Platform core components use the RHEL cryptographic libraries that have been submitted to NIST for FIPS 140-2/140-3 Validation on only the x86_64, ppc64le, and s390x architectures. 18 You can optionally provide the sshKey value that you use to access the machines in your cluster. Note For production OpenShift Container Platform clusters on which you want to perform installation debugging or disaster recovery, specify an SSH key that your ssh-agent process uses. 5.6.7. Configuring the cluster-wide proxy during installation Production environments can deny direct access to the internet and instead have an HTTP or HTTPS proxy available. You can configure a new OpenShift Container Platform cluster to use a proxy by configuring the proxy settings in the install-config.yaml file. Prerequisites You have an existing install-config.yaml file. You reviewed the sites that your cluster requires access to and determined whether any of them need to bypass the proxy. By default, all cluster egress traffic is proxied, including calls to hosting cloud provider APIs. You added sites to the Proxy object's spec.noProxy field to bypass the proxy if necessary. Note The Proxy object status.noProxy field is populated with the values of the networking.machineNetwork[].cidr , networking.clusterNetwork[].cidr , and networking.serviceNetwork[] fields from your installation configuration. For installations on Amazon Web Services (AWS), Google Cloud Platform (GCP), Microsoft Azure, and Red Hat OpenStack Platform (RHOSP), the Proxy object status.noProxy field is also populated with the instance metadata endpoint ( 169.254.169.254 ). Procedure Edit your install-config.yaml file and add the proxy settings. For example: apiVersion: v1 baseDomain: my.domain.com proxy: httpProxy: http://<username>:<pswd>@<ip>:<port> 1 httpsProxy: https://<username>:<pswd>@<ip>:<port> 2 noProxy: example.com 3 additionalTrustBundle: \| 4 -----BEGIN CERTIFICATE----- <MY_TRUSTED_CA_CERT> -----END CERTIFICATE----- additionalTrustBundlePolicy: <policy_to_add_additionalTrustBundle> 5 1 A proxy URL to use for creating HTTP connections outside the cluster. The URL scheme must be http . 2 A proxy URL to use for creating HTTPS connections outside the cluster. 3 A comma-separated list of destination domain names, IP addresses, or other network CIDRs to exclude from proxying. Preface a domain with . to match subdomains only. For example, .y.com matches x.y.com , but not y.com . Use * to bypass the proxy for all destinations. 4 If provided, the installation program generates a config map that is named user-ca-bundle in the openshift-config namespace that contains one or more additional CA certificates that are required for proxying HTTPS connections. The Cluster Network Operator then creates a trusted-ca-bundle config map that merges these contents with the Red Hat Enterprise Linux CoreOS (RHCOS) trust bundle, and this config map is referenced in the trustedCA field of the Proxy object. The additionalTrustBundle field is required unless the proxy's identity certificate is signed by an authority from the RHCOS trust bundle. 5 Optional: The policy to determine the configuration of the Proxy object to reference the user-ca-bundle config map in the trustedCA field. The allowed values are Proxyonly and Always . Use Proxyonly to reference the user-ca-bundle config map only when http/https proxy is configured. Use Always to always reference the user-ca-bundle config map. The default value is Proxyonly . Note The installation program does not support the proxy readinessEndpoints field. Note If the installer times out, restart and then complete the deployment by using the wait-for command of the installer. For example: USD ./openshift-install wait-for install-complete --log-level debug Save the file and reference it when installing OpenShift Container Platform. The installation program creates a cluster-wide proxy that is named cluster that uses the proxy settings in the provided install-config.yaml file. If no proxy settings are provided, a cluster Proxy object is still created, but it will have a nil spec . Note Only the Proxy object named cluster is supported, and no additional proxies can be created. Additional resources For more details about Accelerated Networking, see Accelerated Networking for Microsoft Azure VMs . 5.7. Configuring user-defined tags for Azure In OpenShift Container Platform, you can use the tags for grouping resources and for managing resource access and cost. You can define the tags on the Azure resources in the install-config.yaml file only during OpenShift Container Platform cluster creation. You cannot modify the user-defined tags after cluster creation. Support for user-defined tags is available only for the resources created in the Azure Public Cloud. User-defined tags are not supported for the OpenShift Container Platform clusters upgraded to OpenShift Container Platform 4.16. User-defined and OpenShift Container Platform specific tags are applied only to the resources created by the OpenShift Container Platform installer and its core operators such as Machine api provider azure Operator, Cluster Ingress Operator, Cluster Image Registry Operator. By default, OpenShift Container Platform installer attaches the OpenShift Container Platform tags to the Azure resources. These OpenShift Container Platform tags are not accessible for the users. You can use the .platform.azure.userTags field in the install-config.yaml file to define the list of user-defined tags as shown in the following install-config.yaml file. Sample install-config.yaml file additionalTrustBundlePolicy: Proxyonly 1 apiVersion: v1 baseDomain: catchall.azure.devcluster.openshift.com 2 compute: 3 - architecture: amd64 hyperthreading: Enabled 4 name: worker platform: {} replicas: 3 controlPlane: 5 architecture: amd64 hyperthreading: Enabled 6 name: master platform: {} replicas: 3 metadata: creationTimestamp: null name: user 7 networking: clusterNetwork: - cidr: 10.128.0.0/14 hostPrefix: 23 machineNetwork: - cidr: 10.0.0.0/16 networkType: OVNKubernetes 8 serviceNetwork: - 172.30.0.0/16 platform: azure: baseDomainResourceGroupName: os4-common 9 cloudName: AzurePublicCloud 10 outboundType: Loadbalancer region: southindia 11 userTags: 12 createdBy: user environment: dev 1 Defines the trust bundle policy. 2 Required. The baseDomain parameter specifies the base domain of your cloud provider. The installation program prompts you for this value. 3 The configuration for the machines that comprise compute. The compute section is a sequence of mappings. To meet the requirements of the different data structures, the first line of the compute section must begin with a hyphen, - . If you do not provide these parameters and values, the installation program provides the default value. 4 To enable or disable simultaneous multithreading, or hyperthreading . By default, simultaneous multithreading is enabled to increase the performance of your machines' cores. You can disable it by setting the parameter value to Disabled . If you disable simultaneous multithreading in some cluster machines, you must disable it in all cluster machines. 5 The configuration for the machines that comprise the control plane. The controlPlane section is a single mapping. The first line of the controlPlane section must not begin with a hyphen, - . You can use only one control plane pool. If you do not provide these parameters and values, the installation program provides the default value. 6 To enable or disable simultaneous multithreading, or hyperthreading . By default, simultaneous multithreading is enabled to increase the performance of your machines' cores. You can disable it by setting the parameter value to Disabled . If you disable simultaneous multithreading in some cluster machines, you must disable it in all cluster machines. 7 The installation program prompts you for this value. 8 The cluster network plugin to install. The default value OVNKubernetes is the only supported value. 9 Specifies the resource group for the base domain of the Azure DNS zone. 10 Specifies the name of the Azure cloud environment. You can use the cloudName field to configure the Azure SDK with the Azure API endpoints. If you do not provide value, the default value is Azure Public Cloud. 11 Required. Specifies the name of the Azure region that hosts your cluster. The installation program prompts you for this value. 12 Defines the additional keys and values that the installation program adds as tags to all Azure resources that it creates. The user-defined tags have the following limitations: A tag key can have a maximum of 128 characters. A tag key must begin with a letter, end with a letter, number or underscore, and can contain only letters, numbers, underscores, periods, and hyphens. Tag keys are case-insensitive. Tag keys cannot be name . It cannot have prefixes such as kubernetes.io , openshift.io , microsoft , azure , and windows . A tag value can have a maximum of 256 characters. You can configure a maximum of 10 tags for resource group and resources. For more information about Azure tags, see Azure user-defined tags 5.8. Querying user-defined tags for Azure After creating the OpenShift Container Platform cluster, you can access the list of defined tags for the Azure resources. The format of the OpenShift Container Platform tags is kubernetes.io_cluster.<cluster_id>:owned . The cluster_id parameter is the value of .status.infrastructureName present in config.openshift.io/Infrastructure . Query the tags defined for Azure resources by running the following command: USD oc get infrastructures.config.openshift.io cluster -o=jsonpath-as-json='{.status.platformStatus.azure.resourceTags}' Example output [ [ { "key": "createdBy", "value": "user" }, { "key": "environment", "value": "dev" } ] ] 5.9. Installing the OpenShift CLI You can install the OpenShift CLI ( oc ) to interact with OpenShift Container Platform from a command-line interface. You can install oc on Linux, Windows, or macOS. Important If you installed an earlier version of oc , you cannot use it to complete all of the commands in OpenShift Container Platform 4.16. Download and install the new version of oc . Installing the OpenShift CLI on Linux You can install the OpenShift CLI ( oc ) binary on Linux by using the following procedure. Procedure Navigate to the OpenShift Container Platform downloads page on the Red Hat Customer Portal. Select the architecture from the Product Variant drop-down list. Select the appropriate version from the Version drop-down list. Click Download Now to the OpenShift v4.16 Linux Clients entry and save the file. Unpack the archive: USD tar xvf <file> Place the oc binary in a directory that is on your PATH . To check your PATH , execute the following command: USD echo USDPATH Verification After you install the OpenShift CLI, it is available using the oc command: USD oc <command> Installing the OpenShift CLI on Windows You can install the OpenShift CLI ( oc ) binary on Windows by using the following procedure. Procedure Navigate to the OpenShift Container Platform downloads page on the Red Hat Customer Portal. Select the appropriate version from the Version drop-down list. Click Download Now to the OpenShift v4.16 Windows Client entry and save the file. Unzip the archive with a ZIP program. Move the oc binary to a directory that is on your PATH . To check your PATH , open the command prompt and execute the following command: C:\> path Verification After you install the OpenShift CLI, it is available using the oc command: C:\> oc <command> Installing the OpenShift CLI on macOS You can install the OpenShift CLI ( oc ) binary on macOS by using the following procedure. Procedure Navigate to the OpenShift Container Platform downloads page on the Red Hat Customer Portal. Select the appropriate version from the Version drop-down list. Click Download Now to the OpenShift v4.16 macOS Clients entry and save the file. Note For macOS arm64, choose the OpenShift v4.16 macOS arm64 Client entry. Unpack and unzip the archive. Move the oc binary to a directory on your PATH. To check your PATH , open a terminal and execute the following command: USD echo USDPATH Verification Verify your installation by using an oc command: USD oc <command> 5.10. Alternatives to storing administrator-level secrets in the kube-system project By default, administrator secrets are stored in the kube-system project. If you configured the credentialsMode parameter in the install-config.yaml file to Manual , you must use one of the following alternatives: To manage long-term cloud credentials manually, follow the procedure in Manually creating long-term credentials . To implement short-term credentials that are managed outside the cluster for individual components, follow the procedures in Configuring an Azure cluster to use short-term credentials . 5.10.1. Manually creating long-term credentials The Cloud Credential Operator (CCO) can be put into manual mode prior to installation in environments where the cloud identity and access management (IAM) APIs are not reachable, or the administrator prefers not to store an administrator-level credential secret in the cluster kube-system namespace. Procedure If you did not set the credentialsMode parameter in the install-config.yaml configuration file to Manual , modify the value as shown: Sample configuration file snippet apiVersion: v1 baseDomain: example.com credentialsMode: Manual # ... If you have not previously created installation manifest files, do so by running the following command: USD openshift-install create manifests --dir <installation_directory> where <installation_directory> is the directory in which the installation program creates files. Set a USDRELEASE_IMAGE variable with the release image from your installation file by running the following command: USD RELEASE_IMAGE=USD(./openshift-install version \| awk '/release image/ {print USD3}') Extract the list of CredentialsRequest custom resources (CRs) from the OpenShift Container Platform release image by running the following command: USD oc adm release extract \ --from=USDRELEASE_IMAGE \ --credentials-requests \ --included \ 1 --install-config=<path_to_directory_with_installation_configuration>/install-config.yaml \ 2 --to=<path_to_directory_for_credentials_requests> 3 1 The --included parameter includes only the manifests that your specific cluster configuration requires. 2 Specify the location of the install-config.yaml file. 3 Specify the path to the directory where you want to store the CredentialsRequest objects. If the specified directory does not exist, this command creates it. This command creates a YAML file for each CredentialsRequest object. Sample CredentialsRequest object apiVersion: cloudcredential.openshift.io/v1 kind: CredentialsRequest metadata: name: <component_credentials_request> namespace: openshift-cloud-credential-operator ... spec: providerSpec: apiVersion: cloudcredential.openshift.io/v1 kind: AzureProviderSpec roleBindings: - role: Contributor ... Create YAML files for secrets in the openshift-install manifests directory that you generated previously. The secrets must be stored using the namespace and secret name defined in the spec.secretRef for each CredentialsRequest object. Sample CredentialsRequest object with secrets apiVersion: cloudcredential.openshift.io/v1 kind: CredentialsRequest metadata: name: <component_credentials_request> namespace: openshift-cloud-credential-operator ... spec: providerSpec: apiVersion: cloudcredential.openshift.io/v1 kind: AzureProviderSpec roleBindings: - role: Contributor ... secretRef: name: <component_secret> namespace: <component_namespace> ... Sample Secret object apiVersion: v1 kind: Secret metadata: name: <component_secret> namespace: <component_namespace> data: azure_subscription_id: <base64_encoded_azure_subscription_id> azure_client_id: <base64_encoded_azure_client_id> azure_client_secret: <base64_encoded_azure_client_secret> azure_tenant_id: <base64_encoded_azure_tenant_id> azure_resource_prefix: <base64_encoded_azure_resource_prefix> azure_resourcegroup: <base64_encoded_azure_resourcegroup> azure_region: <base64_encoded_azure_region> Important Before upgrading a cluster that uses manually maintained credentials, you must ensure that the CCO is in an upgradeable state. 5.10.2. Configuring an Azure cluster to use short-term credentials To install a cluster that uses Microsoft Entra Workload ID, you must configure the Cloud Credential Operator utility and create the required Azure resources for your cluster. 5.10.2.1. Configuring the Cloud Credential Operator utility To create and manage cloud credentials from outside of the cluster when the Cloud Credential Operator (CCO) is operating in manual mode, extract and prepare the CCO utility ( ccoctl ) binary. Note The ccoctl utility is a Linux binary that must run in a Linux environment. Prerequisites You have access to an OpenShift Container Platform account with cluster administrator access. You have installed the OpenShift CLI ( oc ). You have created a global Microsoft Azure account for the ccoctl utility to use with the following permissions: Example 5.3. Required Azure permissions Microsoft.Resources/subscriptions/resourceGroups/read Microsoft.Resources/subscriptions/resourceGroups/write Microsoft.Resources/subscriptions/resourceGroups/delete Microsoft.Authorization/roleAssignments/read Microsoft.Authorization/roleAssignments/delete Microsoft.Authorization/roleAssignments/write Microsoft.Authorization/roleDefinitions/read Microsoft.Authorization/roleDefinitions/write Microsoft.Authorization/roleDefinitions/delete Microsoft.Storage/storageAccounts/listkeys/action Microsoft.Storage/storageAccounts/delete Microsoft.Storage/storageAccounts/read Microsoft.Storage/storageAccounts/write Microsoft.Storage/storageAccounts/blobServices/containers/write Microsoft.Storage/storageAccounts/blobServices/containers/delete Microsoft.Storage/storageAccounts/blobServices/containers/read Microsoft.ManagedIdentity/userAssignedIdentities/delete Microsoft.ManagedIdentity/userAssignedIdentities/read Microsoft.ManagedIdentity/userAssignedIdentities/write Microsoft.ManagedIdentity/userAssignedIdentities/federatedIdentityCredentials/read Microsoft.ManagedIdentity/userAssignedIdentities/federatedIdentityCredentials/write Microsoft.ManagedIdentity/userAssignedIdentities/federatedIdentityCredentials/delete Microsoft.Storage/register/action Microsoft.ManagedIdentity/register/action Procedure Set a variable for the OpenShift Container Platform release image by running the following command: USD RELEASE_IMAGE=USD(./openshift-install version \| awk '/release image/ {print USD3}') Obtain the CCO container image from the OpenShift Container Platform release image by running the following command: USD CCO_IMAGE=USD(oc adm release info --image-for='cloud-credential-operator' USDRELEASE_IMAGE -a ~/.pull-secret) Note Ensure that the architecture of the USDRELEASE_IMAGE matches the architecture of the environment in which you will use the ccoctl tool. Extract the ccoctl binary from the CCO container image within the OpenShift Container Platform release image by running the following command: USD oc image extract USDCCO_IMAGE \ --file="/usr/bin/ccoctl.<rhel_version>" \ 1 -a ~/.pull-secret 1 For <rhel_version> , specify the value that corresponds to the version of Red Hat Enterprise Linux (RHEL) that the host uses. If no value is specified, ccoctl.rhel8 is used by default. The following values are valid: rhel8 : Specify this value for hosts that use RHEL 8. rhel9 : Specify this value for hosts that use RHEL 9. Change the permissions to make ccoctl executable by running the following command: USD chmod 775 ccoctl.<rhel_version> Verification To verify that ccoctl is ready to use, display the help file. Use a relative file name when you run the command, for example: USD ./ccoctl.rhel9 Example output OpenShift credentials provisioning tool Usage: ccoctl [command] Available Commands: aws Manage credentials objects for AWS cloud azure Manage credentials objects for Azure gcp Manage credentials objects for Google cloud help Help about any command ibmcloud Manage credentials objects for IBM Cloud nutanix Manage credentials objects for Nutanix Flags: -h, --help help for ccoctl Use "ccoctl [command] --help" for more information about a command. 5.10.2.2. Creating Azure resources with the Cloud Credential Operator utility You can use the ccoctl azure create-all command to automate the creation of Azure resources. Note By default, ccoctl creates objects in the directory in which the commands are run. To create the objects in a different directory, use the --output-dir flag. This procedure uses <path_to_ccoctl_output_dir> to refer to this directory. Prerequisites You must have: Extracted and prepared the ccoctl binary. Access to your Microsoft Azure account by using the Azure CLI. Procedure Set a USDRELEASE_IMAGE variable with the release image from your installation file by running the following command: USD RELEASE_IMAGE=USD(./openshift-install version \| awk '/release image/ {print USD3}') Extract the list of CredentialsRequest objects from the OpenShift Container Platform release image by running the following command: USD oc adm release extract \ --from=USDRELEASE_IMAGE \ --credentials-requests \ --included \ 1 --install-config=<path_to_directory_with_installation_configuration>/install-config.yaml \ 2 --to=<path_to_directory_for_credentials_requests> 3 1 The --included parameter includes only the manifests that your specific cluster configuration requires. 2 Specify the location of the install-config.yaml file. 3 Specify the path to the directory where you want to store the CredentialsRequest objects. If the specified directory does not exist, this command creates it. Note This command might take a few moments to run. To enable the ccoctl utility to detect your Azure credentials automatically, log in to the Azure CLI by running the following command: USD az login Use the ccoctl tool to process all CredentialsRequest objects by running the following command: USD ccoctl azure create-all \ --name=<azure_infra_name> \ 1 --output-dir=<ccoctl_output_dir> \ 2 --region=<azure_region> \ 3 --subscription-id=<azure_subscription_id> \ 4 --credentials-requests-dir=<path_to_credentials_requests_directory> \ 5 --dnszone-resource-group-name=<azure_dns_zone_resource_group_name> \ 6 --tenant-id=<azure_tenant_id> 7 1 Specify the user-defined name for all created Azure resources used for tracking. 2 Optional: Specify the directory in which you want the ccoctl utility to create objects. By default, the utility creates objects in the directory in which the commands are run. 3 Specify the Azure region in which cloud resources will be created. 4 Specify the Azure subscription ID to use. 5 Specify the directory containing the files for the component CredentialsRequest objects. 6 Specify the name of the resource group containing the cluster's base domain Azure DNS zone. 7 Specify the Azure tenant ID to use. Note If your cluster uses Technology Preview features that are enabled by the TechPreviewNoUpgrade feature set, you must include the --enable-tech-preview parameter. To see additional optional parameters and explanations of how to use them, run the azure create-all --help command. Verification To verify that the OpenShift Container Platform secrets are created, list the files in the <path_to_ccoctl_output_dir>/manifests directory: USD ls <path_to_ccoctl_output_dir>/manifests Example output azure-ad-pod-identity-webhook-config.yaml cluster-authentication-02-config.yaml openshift-cloud-controller-manager-azure-cloud-credentials-credentials.yaml openshift-cloud-network-config-controller-cloud-credentials-credentials.yaml openshift-cluster-api-capz-manager-bootstrap-credentials-credentials.yaml openshift-cluster-csi-drivers-azure-disk-credentials-credentials.yaml openshift-cluster-csi-drivers-azure-file-credentials-credentials.yaml openshift-image-registry-installer-cloud-credentials-credentials.yaml openshift-ingress-operator-cloud-credentials-credentials.yaml openshift-machine-api-azure-cloud-credentials-credentials.yaml You can verify that the Microsoft Entra ID service accounts are created by querying Azure. For more information, refer to Azure documentation on listing Entra ID service accounts. 5.10.2.3. Incorporating the Cloud Credential Operator utility manifests To implement short-term security credentials managed outside the cluster for individual components, you must move the manifest files that the Cloud Credential Operator utility ( ccoctl ) created to the correct directories for the installation program. Prerequisites You have configured an account with the cloud platform that hosts your cluster. You have configured the Cloud Credential Operator utility ( ccoctl ). You have created the cloud provider resources that are required for your cluster with the ccoctl utility. Procedure If you did not set the credentialsMode parameter in the install-config.yaml configuration file to Manual , modify the value as shown: Sample configuration file snippet apiVersion: v1 baseDomain: example.com credentialsMode: Manual # ... If you used the ccoctl utility to create a new Azure resource group instead of using an existing resource group, modify the resourceGroupName parameter in the install-config.yaml as shown: Sample configuration file snippet apiVersion: v1 baseDomain: example.com # ... platform: azure: resourceGroupName: <azure_infra_name> 1 # ... 1 This value must match the user-defined name for Azure resources that was specified with the --name argument of the ccoctl azure create-all command. If you have not previously created installation manifest files, do so by running the following command: USD openshift-install create manifests --dir <installation_directory> where <installation_directory> is the directory in which the installation program creates files. Copy the manifests that the ccoctl utility generated to the manifests directory that the installation program created by running the following command: USD cp /<path_to_ccoctl_output_dir>/manifests/* ./manifests/ Copy the tls directory that contains the private key to the installation directory: USD cp -a /<path_to_ccoctl_output_dir>/tls . 5.11. Deploying the cluster You can install OpenShift Container Platform on a compatible cloud platform. Important You can run the create cluster command of the installation program only once, during initial installation. Prerequisites You have configured an account with the cloud platform that hosts your cluster. You have the OpenShift Container Platform installation program and the pull secret for your cluster. You have an Azure subscription ID and tenant ID. Procedure Change to the directory that contains the installation program and initialize the cluster deployment: USD ./openshift-install create cluster --dir <installation_directory> \ 1 --log-level=info 2 1 For <installation_directory> , specify the location of your customized ./install-config.yaml file. 2 To view different installation details, specify warn , debug , or error instead of info . Verification When the cluster deployment completes successfully: The terminal displays directions for accessing your cluster, including a link to the web console and credentials for the kubeadmin user. Credential information also outputs to <installation_directory>/.openshift_install.log . Important Do not delete the installation program or the files that the installation program creates. Both are required to delete the cluster. Example output ... INFO Install complete! INFO To access the cluster as the system:admin user when using 'oc', run 'export KUBECONFIG=/home/myuser/install_dir/auth/kubeconfig' INFO Access the OpenShift web-console here: https://console-openshift-console.apps.mycluster.example.com INFO Login to the console with user: "kubeadmin", and password: "password" INFO Time elapsed: 36m22s Important The Ignition config files that the installation program generates contain certificates that expire after 24 hours, which are then renewed at that time. If the cluster is shut down before renewing the certificates and the cluster is later restarted after the 24 hours have elapsed, the cluster automatically recovers the expired certificates. The exception is that you must manually approve the pending node-bootstrapper certificate signing requests (CSRs) to recover kubelet certificates. See the documentation for Recovering from expired control plane certificates for more information. It is recommended that you use Ignition config files within 12 hours after they are generated because the 24-hour certificate rotates from 16 to 22 hours after the cluster is installed. By using the Ignition config files within 12 hours, you can avoid installation failure if the certificate update runs during installation. 5.12. Logging in to the cluster by using the CLI You can log in to your cluster as a default system user by exporting the cluster kubeconfig file. The kubeconfig file contains information about the cluster that is used by the CLI to connect a client to the correct cluster and API server. The file is specific to a cluster and is created during OpenShift Container Platform installation. Prerequisites You deployed an OpenShift Container Platform cluster. You installed the oc CLI. Procedure Export the kubeadmin credentials: USD export KUBECONFIG=<installation_directory>/auth/kubeconfig 1 1 For <installation_directory> , specify the path to the directory that you stored the installation files in. Verify you can run oc commands successfully using the exported configuration: USD oc whoami Example output system:admin Additional resources See Accessing the web console for more details about accessing and understanding the OpenShift Container Platform web console. 5.13. Telemetry access for OpenShift Container Platform In OpenShift Container Platform 4.16, the Telemetry service, which runs by default to provide metrics about cluster health and the success of updates, requires internet access. If your cluster is connected to the internet, Telemetry runs automatically, and your cluster is registered to OpenShift Cluster Manager . After you confirm that your OpenShift Cluster Manager inventory is correct, either maintained automatically by Telemetry or manually by using OpenShift Cluster Manager, use subscription watch to track your OpenShift Container Platform subscriptions at the account or multi-cluster level. Additional resources See About remote health monitoring for more information about the Telemetry service 5.14. steps Customize your cluster . If necessary, you can opt out of remote health reporting .	[ "ssh-keygen -t ed25519 -N '' -f <path>/<file_name> 1", "cat <path>/<file_name>.pub", "cat ~/.ssh/id_ed25519.pub", "eval \"USD(ssh-agent -s)\"", "Agent pid 31874", "ssh-add <path>/<file_name> 1", "Identity added: /home/<you>/<path>/<file_name> (<computer_name>)", "az vm image list --all --offer rh-ocp-worker --publisher redhat -o table", "Offer Publisher Sku Urn Version ------------- -------------- ------------------ -------------------------------------------------------------- ----------------- rh-ocp-worker RedHat rh-ocp-worker RedHat:rh-ocp-worker:rh-ocp-worker:4.15.2024072409 4.15.2024072409 rh-ocp-worker RedHat rh-ocp-worker-gen1 RedHat:rh-ocp-worker:rh-ocp-worker-gen1:4.15.2024072409 4.15.2024072409", "az vm image list --all --offer rh-ocp-worker --publisher redhat-limited -o table", "Offer Publisher Sku Urn Version ------------- -------------- ------------------ -------------------------------------------------------------- ----------------- rh-ocp-worker redhat-limited rh-ocp-worker redhat-limited:rh-ocp-worker:rh-ocp-worker:4.15.2024072409 4.15.2024072409 rh-ocp-worker redhat-limited rh-ocp-worker-gen1 redhat-limited:rh-ocp-worker:rh-ocp-worker-gen1:4.15.2024072409 4.15.2024072409", "az vm image show --urn redhat:rh-ocp-worker:rh-ocp-worker:<version>", "az vm image show --urn redhat-limited:rh-ocp-worker:rh-ocp-worker:<version>", "az vm image terms show --urn redhat:rh-ocp-worker:rh-ocp-worker:<version>", "az vm image terms show --urn redhat-limited:rh-ocp-worker:rh-ocp-worker:<version>", "az vm image terms accept --urn redhat:rh-ocp-worker:rh-ocp-worker:<version>", "az vm image terms accept --urn redhat-limited:rh-ocp-worker:rh-ocp-worker:<version>", "apiVersion: v1 baseDomain: example.com compute: - hyperthreading: Enabled name: worker platform: azure: type: Standard_D4s_v5 osImage: publisher: redhat offer: rh-ocp-worker sku: rh-ocp-worker version: 413.92.2023101700 replicas: 3", "tar -xvf openshift-install-linux.tar.gz", "./openshift-install create install-config --dir <installation_directory> 1", "controlPlane: 1 platform: azure: settings: securityType: TrustedLaunch 2 trustedLaunch: uefiSettings: secureBoot: Enabled 3 virtualizedTrustedPlatformModule: Enabled 4", "controlPlane: 1 platform: azure: settings: securityType: ConfidentialVM 2 confidentialVM: uefiSettings: secureBoot: Enabled 3 virtualizedTrustedPlatformModule: Enabled 4 osDisk: securityProfile: securityEncryptionType: VMGuestStateOnly 5", "apiVersion: v1 baseDomain: example.com 1 controlPlane: 2 hyperthreading: Enabled 3 4 name: master platform: azure: encryptionAtHost: true ultraSSDCapability: Enabled osDisk: diskSizeGB: 1024 5 diskType: Premium_LRS diskEncryptionSet: resourceGroup: disk_encryption_set_resource_group name: disk_encryption_set_name subscriptionId: secondary_subscription_id osImage: publisher: example_publisher_name offer: example_image_offer sku: example_offer_sku version: example_image_version type: Standard_D8s_v3 replicas: 3 compute: 6 - hyperthreading: Enabled 7 name: worker platform: azure: ultraSSDCapability: Enabled type: Standard_D2s_v3 encryptionAtHost: true osDisk: diskSizeGB: 512 8 diskType: Standard_LRS diskEncryptionSet: resourceGroup: disk_encryption_set_resource_group name: disk_encryption_set_name subscriptionId: secondary_subscription_id osImage: publisher: example_publisher_name offer: example_image_offer sku: example_offer_sku version: example_image_version zones: 9 - \"1\" - \"2\" - \"3\" replicas: 5 metadata: name: test-cluster 10 networking: clusterNetwork: - cidr: 10.128.0.0/14 hostPrefix: 23 machineNetwork: - cidr: 10.0.0.0/16 networkType: OVNKubernetes 11 serviceNetwork: - 172.30.0.0/16 platform: azure: defaultMachinePlatform: osImage: 12 publisher: example_publisher_name offer: example_image_offer sku: example_offer_sku version: example_image_version ultraSSDCapability: Enabled baseDomainResourceGroupName: resource_group 13 region: centralus 14 resourceGroupName: existing_resource_group 15 outboundType: Loadbalancer cloudName: AzurePublicCloud pullSecret: '{\"auths\": ...}' 16 fips: false 17 sshKey: ssh-ed25519 AAAA... 18", "apiVersion: v1 baseDomain: my.domain.com proxy: httpProxy: http://<username>:<pswd>@<ip>:<port> 1 httpsProxy: https://<username>:<pswd>@<ip>:<port> 2 noProxy: example.com 3 additionalTrustBundle: \| 4 -----BEGIN CERTIFICATE----- <MY_TRUSTED_CA_CERT> -----END CERTIFICATE----- additionalTrustBundlePolicy: <policy_to_add_additionalTrustBundle> 5", "./openshift-install wait-for install-complete --log-level debug", "additionalTrustBundlePolicy: Proxyonly 1 apiVersion: v1 baseDomain: catchall.azure.devcluster.openshift.com 2 compute: 3 - architecture: amd64 hyperthreading: Enabled 4 name: worker platform: {} replicas: 3 controlPlane: 5 architecture: amd64 hyperthreading: Enabled 6 name: master platform: {} replicas: 3 metadata: creationTimestamp: null name: user 7 networking: clusterNetwork: - cidr: 10.128.0.0/14 hostPrefix: 23 machineNetwork: - cidr: 10.0.0.0/16 networkType: OVNKubernetes 8 serviceNetwork: - 172.30.0.0/16 platform: azure: baseDomainResourceGroupName: os4-common 9 cloudName: AzurePublicCloud 10 outboundType: Loadbalancer region: southindia 11 userTags: 12 createdBy: user environment: dev", "oc get infrastructures.config.openshift.io cluster -o=jsonpath-as-json='{.status.platformStatus.azure.resourceTags}'", "[ [ { \"key\": \"createdBy\", \"value\": \"user\" }, { \"key\": \"environment\", \"value\": \"dev\" } ] ]", "tar xvf <file>", "echo USDPATH", "oc <command>", "C:\\> path", "C:\\> oc <command>", "echo USDPATH", "oc <command>", "apiVersion: v1 baseDomain: example.com credentialsMode: Manual", "openshift-install create manifests --dir <installation_directory>", "RELEASE_IMAGE=USD(./openshift-install version \| awk '/release image/ {print USD3}')", "oc adm release extract --from=USDRELEASE_IMAGE --credentials-requests --included \\ 1 --install-config=<path_to_directory_with_installation_configuration>/install-config.yaml \\ 2 --to=<path_to_directory_for_credentials_requests> 3", "apiVersion: cloudcredential.openshift.io/v1 kind: CredentialsRequest metadata: name: <component_credentials_request> namespace: openshift-cloud-credential-operator spec: providerSpec: apiVersion: cloudcredential.openshift.io/v1 kind: AzureProviderSpec roleBindings: - role: Contributor", "apiVersion: cloudcredential.openshift.io/v1 kind: CredentialsRequest metadata: name: <component_credentials_request> namespace: openshift-cloud-credential-operator spec: providerSpec: apiVersion: cloudcredential.openshift.io/v1 kind: AzureProviderSpec roleBindings: - role: Contributor secretRef: name: <component_secret> namespace: <component_namespace>", "apiVersion: v1 kind: Secret metadata: name: <component_secret> namespace: <component_namespace> data: azure_subscription_id: <base64_encoded_azure_subscription_id> azure_client_id: <base64_encoded_azure_client_id> azure_client_secret: <base64_encoded_azure_client_secret> azure_tenant_id: <base64_encoded_azure_tenant_id> azure_resource_prefix: <base64_encoded_azure_resource_prefix> azure_resourcegroup: <base64_encoded_azure_resourcegroup> azure_region: <base64_encoded_azure_region>", "RELEASE_IMAGE=USD(./openshift-install version \| awk '/release image/ {print USD3}')", "CCO_IMAGE=USD(oc adm release info --image-for='cloud-credential-operator' USDRELEASE_IMAGE -a ~/.pull-secret)", "oc image extract USDCCO_IMAGE --file=\"/usr/bin/ccoctl.<rhel_version>\" \\ 1 -a ~/.pull-secret", "chmod 775 ccoctl.<rhel_version>", "./ccoctl.rhel9", "OpenShift credentials provisioning tool Usage: ccoctl [command] Available Commands: aws Manage credentials objects for AWS cloud azure Manage credentials objects for Azure gcp Manage credentials objects for Google cloud help Help about any command ibmcloud Manage credentials objects for IBM Cloud nutanix Manage credentials objects for Nutanix Flags: -h, --help help for ccoctl Use \"ccoctl [command] --help\" for more information about a command.", "RELEASE_IMAGE=USD(./openshift-install version \| awk '/release image/ {print USD3}')", "oc adm release extract --from=USDRELEASE_IMAGE --credentials-requests --included \\ 1 --install-config=<path_to_directory_with_installation_configuration>/install-config.yaml \\ 2 --to=<path_to_directory_for_credentials_requests> 3", "az login", "ccoctl azure create-all --name=<azure_infra_name> \\ 1 --output-dir=<ccoctl_output_dir> \\ 2 --region=<azure_region> \\ 3 --subscription-id=<azure_subscription_id> \\ 4 --credentials-requests-dir=<path_to_credentials_requests_directory> \\ 5 --dnszone-resource-group-name=<azure_dns_zone_resource_group_name> \\ 6 --tenant-id=<azure_tenant_id> 7", "ls <path_to_ccoctl_output_dir>/manifests", "azure-ad-pod-identity-webhook-config.yaml cluster-authentication-02-config.yaml openshift-cloud-controller-manager-azure-cloud-credentials-credentials.yaml openshift-cloud-network-config-controller-cloud-credentials-credentials.yaml openshift-cluster-api-capz-manager-bootstrap-credentials-credentials.yaml openshift-cluster-csi-drivers-azure-disk-credentials-credentials.yaml openshift-cluster-csi-drivers-azure-file-credentials-credentials.yaml openshift-image-registry-installer-cloud-credentials-credentials.yaml openshift-ingress-operator-cloud-credentials-credentials.yaml openshift-machine-api-azure-cloud-credentials-credentials.yaml", "apiVersion: v1 baseDomain: example.com credentialsMode: Manual", "apiVersion: v1 baseDomain: example.com platform: azure: resourceGroupName: <azure_infra_name> 1", "openshift-install create manifests --dir <installation_directory>", "cp /<path_to_ccoctl_output_dir>/manifests/* ./manifests/", "cp -a /<path_to_ccoctl_output_dir>/tls .", "./openshift-install create cluster --dir <installation_directory> \\ 1 --log-level=info 2", "INFO Install complete! INFO To access the cluster as the system:admin user when using 'oc', run 'export KUBECONFIG=/home/myuser/install_dir/auth/kubeconfig' INFO Access the OpenShift web-console here: https://console-openshift-console.apps.mycluster.example.com INFO Login to the console with user: \"kubeadmin\", and password: \"password\" INFO Time elapsed: 36m22s", "export KUBECONFIG=<installation_directory>/auth/kubeconfig 1", "oc whoami", "system:admin" ]	https://docs.redhat.com/en/documentation/openshift_container_platform_installation/4.16/html/installing_on_azure/installing-azure-customizations
function::ansi_reset_color	function::ansi_reset_color Name function::ansi_reset_color - Resets Select Graphic Rendition mode. Synopsis Arguments None Description Sends ansi code to reset foreground, background and color attribute to default values.	[ "ansi_reset_color()" ]	https://docs.redhat.com/en/documentation/Red_Hat_Enterprise_Linux/7/html/systemtap_tapset_reference/api-ansi-reset-color
Eclipse Temurin 8.0.402 release notes	Eclipse Temurin 8.0.402 release notes Red Hat build of OpenJDK 8 Red Hat Customer Content Services	null	https://docs.redhat.com/en/documentation/red_hat_build_of_openjdk/8/html/eclipse_temurin_8.0.402_release_notes/index
function::errno_str	function::errno_str Name function::errno_str - Symbolic string associated with error code Synopsis Arguments err The error number received Description This function returns the symbolic string associated with the giver error code, such as ENOENT for the number 2, or E#3333 for an out-of-range value such as 3333.	[ "errno_str:string(err:long)" ]	https://docs.redhat.com/en/documentation/Red_Hat_Enterprise_Linux/7/html/systemtap_tapset_reference/api-errno-str