I am not directly involved in its deployment, but I am planning to build an application. At that time, I will be deploying it myself. In the organization where I work as a consultant, there is a segregation of roles. There is a production support team, there is a development team, and there is a DevOps team. I am a part of the development team.

Its initial setup is straightforward. It is not complex. It also depends on the architecture, high availability, etc.

In terms of deployment, earlier, it was on-prem, but now, it is on the cloud. My client runs about 150 VMs on the cloud in the production, staging, and QA environments. Most of the things have been consolidated into VMs. The migration is complete. It was not that complex.

The initial setup is straightforward. We used Terraform to make it even simpler, but I don't think it was complex, to begin with. Deployment for one server takes a couple of hours. If we're just looking at a single server, or if we're building out a small cluster, deployment may take a day or two.

The initial setup is straightforward. You start off by putting a disk in and specifying what partitions you want. Then, you can opt for a minimal OS or something with more features, such as a web server OS. Once you select what you need, it does some initial configuration and setup.

We always use a minimal configuration and build up from there. Our deployment process is a mix of legacy, where we do a manual install, versus a fully automated installation using Ansible.

For an end-to-end build, we normally take about 20 minutes. That's going from a bare minimum template to all of our security, InfoSec requirements, register to Satellite, register to Insights, etc. 

In summary, the installation is as straightforward as it can be for Linux OS.

The initial setup of Red Hat Enterprise Linux is very straightforward. It is not much different from any other Linux operating system. Most of the things we need to consider when deploying Linux are relatively standard. Therefore, Red Hat Enterprise Linux is easy to deploy and maintain. If we know how to administer Linux operationally, then Red Hat Enterprise Linux should be easy to deploy.

I have been involved in the deployment of OpenShift. It is pretty straightforward. We just need to get the licensing, and we just need to create a pool for our containers session in Red Hat Satellite. We can do the configuration from there. It does not take long because we are adding the nodes to OpenShift. During the scale-up process, we only need to subscribe to the nodes with the Red Hat subscription. It does not take much time. If we have a good spec, the scale-up would not take much time. It would take less than twenty minutes. It is pretty fast.

In terms of maintenance, when we have the bug report, we need to do the security assessments. Over time, there might be some bugs related to some packages. At that time, if it is critical, we will be scheduling a maintenance activity on our platform. 

Red Hat provides high availability from the application perspective. You get high availability when you are using OpenShift, so when you are doing a maintenance activity on the OpenShift side, there would not be any downtime. The high availability is very good. For the end-users, there would not be any application outages if you configure your application with proper replicas. They would not even realize that there is a maintenance activity happening to the underlying workers.

The initial setup of RHEL is about 10 times easier than Windows. It is literally just click, click, bang. It just installs. If you have a problem with the install, you just reinstall it. It takes very little time to install, about 10 minutes. As a base image, it is very easy to set up. Then, you have post tweaks that you need to do, and I have scripts for that. Since I can script it all, I just run another command, then boom and it is all done.

For my implementation strategy, I build the gold image, which is basically just going through the CD and making my selections for a base image. Then, I freeze that image, which is on VMware, and run my scripts. My scripts basically set up logs for auditing. Whether we are going to ship logs or keep logs locally, it sets up the basic users. For instance, it will set up my account with pseudo access so I can do the remainder of the work using my account with pseudo access. It sets up tracing, the host name, IP addresses, and ESXi host files. It sets up the basic fundamentals of an operating system and gets it ready for deploying the application. 

There are also different kinds of file systems that need to be deployed and additional users that need to be added. Those are all manual processes.

I do the Red Hat Enterprise Linux upgrades. It's straightforward because I can just run Leapp to upgrade it

For the majority of our use cases for Red Hat, we have on-prem deployments. There are some things that they are trying to spin up on AWS. I do not know if they are cloud-native apps or not, but I know our developers are now moving on to it.

I have been involved in the initial setup, upgrades, and migration of Red Hat Enterprise Linux. I did not have any problems while going from major OS versions. I always push new upgrades or homogeneous migrations, such as from version 6 to version 7 to version 8. There is probably an option to upgrade in place. Overall, with Red Hat OS, I have not seen many problems. A long time ago, when they went from Python 2 to Python 3, there were certain things we had to change in the script.

I know that Red Hat is moving to Wayland from X11, but I do not see any problems there. From Satellite 5 to 6, it was a bit hard in the beginning, but now, it is pretty self-explanatory. Overall, everything about which we had questions was very well documented.

In terms of our upgrade and/or migration plans to stay current, first, we look at the EOL and the roadmap of Red Hat because of security. We used to offer every single version before the said EOL happened, but now, we just do an n-minus-one. We try to maintain the newest and one level below version. SAP users are the biggest Red Hat Enterprise Linux users in our environment. They have a particular PAM and upgrade path that they have to do with Red Hat. We also wait to be certified to certain versions, but our main strategy is the newest and one major version down. We try to get everybody off the other versions.

Our provisioning is all done using VMware products. We have a vRealize automation, now called the Aria automation, to spin it up. Patching is done through Satellite. I do not do it, but when I watch them doing it, it seems it is just using remote SSH commands against the list of non-prod and prod servers. It is something simple. We do not seem to be doing anything complicated. I am wondering if there is a better way to do versioning control or patching and whatnot, but currently, it is very simple.

I am satisfied with the management experience not only in terms of patching but also the day zero to day one or day two stuff. We are interested in utilizing Ansible to eliminate human error and whatnot. During provisioning, we have Pearl scripts that we have to manually trigger. I know we can use Ansible for that, but it comes down to the cost of entry which is still very high. 

We use Red Hat Enterprise Linux in the cloud. We have Azure because it is the corporate standard. We do not have any concerns about using Red Hat Enterprise Linux in the cloud. Obviously, everything in the cloud is more exposed than everything on-prem, but it has got good, sensible, and secure defaults built in, so there are no concerns there.

In terms of Red Hat Enterprise Linux upgrades, when we upgraded Ansible this fall, that pushed us from Red Hat Enterprise Linux 7 to Red Hat Enterprise Linux 8. It should be a little easier from now on. Now that we have made the big jump from the older Ansible to AAP, we will probably be upgrading the systems on a quarterly basis.

The initial setup was easy.

The initial setup is complicated, but with Red Hat Enterprise Linux nine, there is a graphical web interface where we can create a new image every week. We have created a golden template that enables us to update the image every month and upload it to both our private and public clouds for usage. 

The deployment time depends on whether we have a template or not. With a template, deployment can take between five and ten minutes. If we have to install the software, the time it takes depends on our internet bandwidth. Ten gigabits of bandwidth can take around 15 minutes to install.

The initial setup was complex because we were using a newer version of Red Hat Enterprise Linux for the server team's workloads. Normally, we go with Red Hat Enterprise Linux for hardware, but this time we got a better deal from a different vendor whose IPMI Redfish interface wasn't as advanced as Red Hat Enterprise Linux's. This caused some issues specifically related to deploying the newer version. However, once we managed to overcome most of those challenges, the use of Ansible for OS deployment became more straightforward.

The initial setup wasn't complex, but since we wanted to make it easier to use, it became harder to make it work the way we wanted. Not out of the box, so we can just build a server that is ready to be deployed right away without any more interventions.

We use RHEL with AWS because it's easier for us to maintain since we create our own AMIs and we update that as we need it. So we don't need to follow their schedule until we get it more secure and more reliable for us.

RHEL is very easy to configure and deploy.

When we're talking about RHEL in the cloud, Azure is probably the better platform for RHEL. AWS has some licensing issues. The business end of using RHEL on AWS is not as mature or fleshed out as it is on Azure.

Incidentally, I'm not a big fan of Azure. Rather, I have most of my experience in AWS, but Azure deploys Red Hat without issue. We don't have to worry about licensing and connecting things. Everything is already bound to Azure AD, and that makes it really nice because on-premises, we have to do that manually.

For the on-premises deployment, part of the deployment package requires that we add our Red Hat servers to our local AD. But in Azure, it just does everything for you all within one PowerShell command. Ultimately, deploying Red Hat in Azure is much easier than deploying it either on-premises or on AWS.

I am no longer involved in its deployment. I last deployed it about four years ago.

In terms of maintenance, every server requires some kind of maintenance, but we have everything automated. We don't put any effort into it. 

Upgrading the versions is straightforward. All the stakeholders from the system side, database side, and consultants are involved in the updates. 

The solution is deployed on both on-premises and the cloud. We have customers on the cloud server platform where we run their network, and we manage through Satellite. We also have it on-premises.

I was involved in the deployment of the solution. We created some automation, so the setup phase is straightforward. We use templates for all of those, but to manage the templates, and what it will include, we use external tools to make it easier for the deployment automation.

Regarding deployment time, it can be done in seconds. It also depends on what application we are speaking about since for an OS or more difficult solution, like Red Hat Satellite, you need more time.

The setup was complicated only because the applications we were trying to run were not certified to run on RHEL. It was version 6.8, so we worked with major global vendors to add the certification for the versions we were trying to run. That was the complexity. The application always worked beautifully, and the performance was excellent. It wasn't a question of getting the development to work; obtaining an issue of getting certification for the platform, which is required for any financial institution.

From a development perspective, we proved the concept and ran a mirror of production and development to demonstrate the improvements in OpEx and performance. Getting it up and running in parallel was the key to getting it all to work correctly, and it was instrumental in convincing any dissenting voices of the value. 

The deployment took less than three months, but the certification took nine.
The team supporting the first application numbered around 50, and the small group involved in the initial switch had about eight people.

The entire application is run exclusively on RHEL, so the whole operation team is probably around 40 or 50 people. It's worth adding that our overall group runs about 20,000 servers, so it's challenging to say overall what the RHEL footprint is.

After deployment, RHEL requires maintenance to keep the solution up to date. Security requirements tend to be more prohibitive or less encouraging of change. It's a question of changing mindsets and explaining that something doesn't have to be legacy-tested to update. The security benefits of updating are more critical than testing to ensure the update hasn't introduced more flaws.

The initial setup was pretty straightforward. I've even set servers up at home on a pretty regular basis. I have my own lab, so I've deployed it and it's pretty straightforward. With RHEL, the setup is nice because you get a GUI, so any Windows-based user is going to be familiar with the GUI and know what to look at. They can deploy software as needed, right there from the menu. From a TextBase, you can script it to where all you have to do is run a script and it'll deploy the server quickly. It's pretty straightforward.

Personally, I wouldn't be able to speak to the installation. Having a single point is always a benefit because then you don't have to jump around multiple points to download software and to deploy your solution. The only thing about it is with Docker, a lot of times you have to go out to the Docker site to download the newest versions.

If you're running Satellite, it's even easier because all your current patches are downloaded. The iOS is already there and a lot of time is it's a straight script that you can deploy quickly. The single-point install is a good thing.

Depending on what you're running it on and what kind of equipment you're running, it can take anywhere between 20 minutes to an hour. That depends on the equipment.

We use certain tools from HashiCorp, such as Packer, so deploying it is very simple. We have a script that runs every night, and it creates via the CI, goes up to GitLab, gets whatever it needs, such as parameters, and sends it to Packer. Packer grabs the ISO, and it creates a very specific, customized deployment. It's done with a couple of right clicks. That's it.

Regarding centralization, we have a combination of on-premises and cloud environments where development activities take place. Currently, I don't see a specific use case for centralized development and operations, but Red Hat Enterprise Linux is being widely used both in on-premises and cloud setups. As for hybrid deployments, I haven't personally come across many instances of it. There may be a few customers who are utilizing it but not with us thus far.

Red Hat Enterprise Linux's built-in security features in terms of ensuring application and container portability are not an easy task. Although it's not my personal experience, I've observed that in the industry, there is a lot of discussion about moving toward container-based applications. However, only a small number of clients, especially those in highly regulated industries like banking, government, and oil and gas, have actually embraced containerization. They are facing significant challenges when it comes to adopting container-based applications. Many of them still rely on legacy systems running on-premises, such as mainframes.

We have been working with different operating systems, and we also know most of the technical requirements, so it is easy for us. Usually, the OS installation takes a maximum of 25 minutes. If you are making extra file systems, such as for Oracle, it takes 10 to 15 minutes extra. A desktop or a single file system doesn't require much time. We already have scripts. We just run the scripts and everything is done by the scripts. Previously, it used to take two or three hours, but now, things have changed, and we're making life easier.

When I deployed RHEL initially, it was not very straightforward, but it's relatively easy today. The difference is the improvements to Satellite. Satellite Version 5 was kind of clunky. Version 6 seemed a little more straightforward and reliable. We don't use any kickstart, golden image, and roll and update, so there's not much to our strategy. 

The initial deployment took over a week, but it took about two days when we moved to RHEL 6. 

I joined the organization after deployment and wasn't involved in the implementation. 

I'm not sure if the solution requires any maintenance. 

The patching has been good, but we scan with Qualys all the time. It comes up with thousands of EIDs all the time, but putting on the patches seems to resolve that.

We're operating right now from 7.9 to 8.6. We have to go with the supported versions. We did qualify for RHEL 9. 

The initial deployment was straightforward. The deployment time depends on two factors: the first factor is the infrastructure specs, and the second factor is what we are deploying with the operating system. For a minimal server, deployment takes five minutes. For a server with a graphical user interface, it can take up to 20 minutes.

The initial setup is pretty straightforward but can be tedious at times because of the compliance things that we have to implement. 

I just sat in on the training or the demo for the deployment platform, and we're already planning on setting up the Ansible automation platform where we also want to look into setting up this deployment tool because we do a lot of ISOs. We do a lot of kickstarts. We don't do any of the cloud tenants. We probably will switch to using the on-premise disconnected deployment capability because we can preconfigure everything and then run Ansible after the fact to get it all compliant.

We are currently in the process of reviewing our initial solution for upgrading from Red Hat Enterprise Linux 7 to Red Hat Enterprise Linux 8. The in-place upgrade for the airgap environment is an area where we are still struggling to understand the documentation. However, Red Hat has been very supportive and has offered us pathways to move forward. We do not have much to say at this time, as we are still in the middle of the process.

When we upgraded Red Hat Enterprise Linux 6 to Red Hat Enterprise Linux 7, it took us around six months due to external factors not related to Red Hat Enterprise Linux.

I do not know the setup details. The solution was implemented in 2014 and I joined the team in 2018.

The setup was completed twenty years ago so I do not have details. 

The solution is easy to troubleshoot if you have familiarity with Unix systems. Any system of this scale will require maintenance but it is relatively straightforward. 

The initial deployment is straightforward. There's no problem. However, it also depends on what we want to achieve. Some of the options add a little complexity. It isn't very complicated, but it requires a different method. Overall, the general installation and configuration are effortless, and we don't have any issues. The initial installation can be done in 15-30 minutes, depending on the computing and storage capacity. 

We have one administrator experienced in Red Hat Enterprise Linux and enterprise Linux for maintence. We prefer a certified person who can understand the data complexities and advanced configuration, but a technician doesn't need to be a specialist to conduct the installation. 

The initial setup is straightforward. I installed Red Hat Enterprise Linux using the stick method. I had to create nine different partitions, all of which were encrypted. This is where things got a little complicated. We need to decide whether to create a LUKS partition or partition and build our image on top of a LUKS partition. Initially, I was individually encrypting each partition using the "encrypt" option. However, this is not ideal because we cannot grow or shrink an LVM partition that is on an encrypted partition. Once the partition is created, it is set in stone. So, I needed to figure out how to encrypt just the partition and then create an LVM partition on top of the encrypted partition, such as SDA3. This was a bit of a challenge, and there is not a lot of documentation on how to do this. The documentation that is available is a bit confusing, and I got lost a few times. Once I figured it out, it was not too bad. The entire deployment process takes about 20 minutes.

The initial setup is very easy. It took about four or five hours.

The solution requires maintenance and constant updates.

The solution is easy to set up but sometimes there are issues with custom software deployments. For example, we want to use Ansible in RHEL 8 but the software is only supported in RHEL 7. We question whether we should install an old version of Python to get things to run. 

The solution is pretty easy to troubleshoot. 

The initial setup of the solution is relatively simple. It's pretty much click, click, click, done. And the single subscription and install repository for all types of systems make the purchasing and installation processes easier.

Depending on the platform, deployment of a single RHEL instance could take anywhere from  five to 30 minutes. Bare metal is going to take longer than deploying the cloud.

The upgradation and migration parts attached to the solution can be described as a very straightforward and easy process. Sometimes, I migrate from the on-premises version to the cloud, which I find to be a very easy process. The servers are up and running very well, so I have no problems with the product.

I have experience with the on-premises version of the product.

I was not involved in the installation. I have not worked on the OS level and I'm not involved in the migration to the cloud.

We have eight to nine people on our team that may handle some maintenance tasks. If there are any issues, we can patch and fix them. We go through the portal to handle patching and maintenance. We'll check the system pre and post patching.

The deployment complexity is based on the project and the architect of the particular solutions. There are scripts that we can use to perform the upgrades or migration. The number of people required for upgrades or migration depends on the size of the solution. For a small solution, we can automate and don't require any people. If we are using a third-party solution already in place we can achieve the same goal without a large team.

It was very straightforward. We've pushed in further to make our own ISOs, so we're making sure that everything is getting the same applications and everything is deployed across the board, and we are able to virtualize in some cases. It has been good.

The first time I deployed Red Hat Enterprise Linux, I was swapping floppies. It has gotten a lot easier since then. The deployment process is straightforward. I usually map an ISO, and then check a bunch of boxes and let it run. I can have a server up and running in about fifteen minutes. After validating the system and installing the necessary software, I can deliver it to the end user in an hour. I know that if I automate the process, I could probably reduce the time to six minutes.

I was the main engineer during the initial deployment of the product. The initial setup was straightforward. Whatever was in the documentation was exactly what was meant to be done.

We did not struggle with the documentation because I have been an engineer for years. Someone who is just getting started might have a different perspective on the ease of setup.

As a developer, I find the initial setup to be easy. Deployment takes a few hours, but I understand the server, so it is not a problem. I do not actually do the deployment; the infrastructure team handles that. They made the process easier and faster, and on average, deployment now takes around four to six hours.

It is straightforward. It is not much complex. Previously, we used to do everything manually. Now, we have multiple scripts and multiple tools that make it easy to deploy.

The first deployment took a few months because we were new to RHEL. We had to do a lot of homework from our side as well as on the product side, so it took us a few months to implement it. Now, we are well-familiar with the product. We know how the product works, so we plan accordingly, and we are able to finish according to a deadline.

RHEL has accelerated the deployment of cloud-based workloads. We also work with a local partner of RHEL, and they give us professional services. They do have some customized tools for partner deployment, and their professional services team is able to help us to accelerate all the workloads to the public cloud by using those tools. This acceleration time depends upon the workload size and whether we are going for a normal Infrastructure-as-a-Service or Platform-as-a-Service. It also depends on how we are migrating our monolithic application to the microservices application.

The deployment is straightforward. However, there’s a learning curve to understand it. The deployment would be difficult for a newcomer, but it’s normal. We use automation tools. The deployment takes us a few minutes because we use scripts.

The solution is deployed on the cloud. However, it’s an on-premise solution from the Dutch government. We do not have control over the physical servers. We just work on virtual machines. The license fees are paid by another government agency. We take machines, and then they bill us for it.

I was involved in the initial testing. We tested it until we could make it work fine and then we provided documentation for the people who would put it into production. But we only did the testing. We work on how it is deployed and document any problems we run into and how to fix them.

The ease or difficulty of the setup will depend on a number of things. 

RHEL was already there when I joined the organization, so I inherited it. In terms of maintenance, we try to keep it up to date. 

The complexity of the initial setup will depend on the requirements of your organization. Generally, I find it pretty straightforward. There is good documentation for it. The installer works great. I haven't had any issues.

Most companies go with some sort of way to deploy an image. I have done standard, straight installs, installing the solution to laptops. That would be the equivalent of installing it to bare-metal.

It takes maybe 15 to 20 minutes to deploy a server. That is just with all the automation that we have added as well as having to deploy a base OS image, hardening, and adding all the software that we want. For a company-base installation, it takes about 20 minutes.

As an admin, I was not involved in the setup process. 

If there is any maintenance needed, we get support from the Red Hat team.  If anything comes up on the operating side, our team will take care of it. 

We have a hybrid environment. We do have some things in the cloud. We're using both Azure and AWS as our cloud providers.

I was involved in the process of migrating our Jenkins servers to Red Hat Enterprise Linux 9. It was not straightforward or complex because we changed a lot of things about our deployment. We tried to improve and streamline, and in the process, we broke some of our pipelines. 

It was not smooth, but that was not necessarily because of Red Hat Enterprise Linux, except for some of the security upgrades. We could not use the old RSA keys that we were using with RHEL 6 with RHEL 9. This meant that we either had to loosen our security by allowing legacy keys or tighten things down. We chose to tighten things down.

Another challenge is that we have some old Red Hat Enterprise Linux applications that are running on very old versions. We are trying to get everything off of RHEL 6 and 7 and onto RHEL 9, but there are a few applications that are stuck on RHEL 6 for various reasons.

We are getting rid of all of our Linux servers, so the biggest challenge right now is migrating our applications to RHEL 9.

We build our own deployment method. 

I was involved in the deployment. Our team managed the process. It's pretty straightforward. We handle implementation, tuning, and patching. 

How long it takes to implement the product depends. We're trying to mitigate the time by automating with Ansible. We want to handle one VM or server in five or fewer minutes, however, it can take days. At this point, we can provision servers in a few minutes. It's becoming faster. 

We have a team of ten to run the infrastructure on the OS level. 

Personally, I find the deployment process straightforward, but I've been doing it for quite some time. I can't speak for someone who is new to it. However, from my experience, it's relatively straightforward. I've been in this role for a while, so I'm familiar with the process.

Currently, we use Azure AVS, which allows us to migrate existing physical machines to the cloud until we can fully modernize them. It's much easier than it was a couple of years ago, but there is still some work to be done. Overall, it's manageable for us to move workloads between the cloud and on-premises or data center environment using Red Hat Enterprise Linux.

The setup is straightforward. 

For one client's cloud setup, we created virtual machines and provisioned the operating system on the solution. The cloud solution provides images for the operating system so is pretty easy to install. Just click, click, click and that is it. 

For other cases, we had to install from scratch at boot but had well-documented instructions so we didn't have any issues. 

These use cases were not too complex so the focus was more on installing patches and packages that ensure compatibility with the solution. We find prerequisites for implementation in order for it to work. We focus on a strategy that makes sure we have the correct kernel parameters, the right center for settings, and the utilities needed for managing the operating system in conjunction with the database. For example, a lot of C++ compilers need to be installed. Everything that is part of the pre-install packages can be done by a DPA as well. 

The initial setup is not complex. First, we had to identify our requirements and the features provided by Red Hat. That didn't take so much time. In three to four weeks, we were there.

I automate everything. I write the automation that creates the VM templates. Once my automation is done, there is really nothing to set up.

It was complex at the beginning because we only knew the basics. We didn't know the purpose of many of the tools and how to implement them. We started training ourselves. It took us two years to implement or to make this change.

We first installed it on a few of our servers, but then we started working with OpenShift. We have a private cloud in our infrastructure, and it is me and one colleague doing this job.

Deploying Red Hat Enterprise Linux is straightforward, but the complexity and time required depend on whether we are deploying on a virtual machine or a desktop. If we have the correct documentation, the total process can be completed in three to five days.

I have used the Image Builder Tool, but in the latest deployment, I pulled down the repository from the Docker hub. We use our own XML file and create the repository. It's a two or three-day design process for Red Hat Linux. We need one data resource for that process and a second engineer on the support side if we want to set up more servers from their on-site services.

I was involved in the OpenShift deployments. We are also directly involved in every version of Red Hat Enterprise Linux. We are involved in the proof of concept. Its deployment is straightforward.

I was not involved in the initial deployment but it was straightforward. The deployment took around 15 minutes per machine.

Its deployment is very easy. It does not take long. Its maintenance is also easy. We can expand the storage for the operating system or the web server.

It was very straightforward. When we did the proof of concept, we had everything ready within two or three days, and then the engineers who came to deploy it did it in a day's time once we had all the infrastructure up and running. This was just for the proof of concept.

With regard to the implementation, they had a timeline, and they did deliver before the timeline.

It has been deployed on Nutanix as well. They are present even in the marketplace for AWS. It's a straightforward installation. They have two categories: UPI and IPI, and the installations are very straightforward, but it requires a lot of expertise if you want to deploy it on a public cloud.

The initial setup is straightforward. We can copy and paste any templates we need into the environment.

I have been involved in the upgrades and some migrations for migrating things from Solaris. We also had CentOS, which was converted to DevStream, so we have had to change those to Red Hat. The upgrades and migrations were not terribly difficult. Usually, the tools were there. We called support when we ran into problems, but for the most part, it worked.

I have used Convert2RHEL. It was a bit helpful. It did the job.

We mostly use Ansible for deployment, patching, and managing the system in general. Our experience has been good. I am looking at some of the newer things they have at the conference that we have not had a chance to play with, but it meets our needs.

It's pretty simple to install the product. However, some tools required to install it are missing.

Most of our clients are institutions or public organizations. They have their own infrastructure for security reasons. Having a cloud environment has its own advantages and having your own infrastructure has its advantages. I prefer having my own infrastructure. When you have your own infrastructure, you have more control over all the processes and data of your organization, but I understand that having a cloud setup has advantages because you can manage and automate several systems or processes in the organization.

It's easy to install Red Hat Enterprise Linux. It's not difficult to install. You have the typical steps of the installation of any Linux-based operating system. Anyone can install this operating system. If you want to install servers such as an Apache server or a web application server, you need certain skills, but the installation of the operating system is easy.

The initial deployment and setup of OpenShift were straightforward. We ran into some issues that we were able to work through. The Red Hat team did provide a lot of support to get us there.

I've been involved in deployment, but it depends on the client. I've done everything from architectural design to installation and administration for specific clients. Setting up RHEL is pretty straightforward if you know what you need to know. Of course, you have to do your homework before. For example, if you are deploying it on a VM, you need to see the size you need and what else you have to install. 

When someone orders a server, we typically tell them the deployment will take half a day, but the installation takes around an hour. You may need to install other things, but the out-of-the-box operating system takes about an hour.

We're just one team who manages the infrastructure for one department. It's highly specific. There's a specialized market team that does stock exchanges and financial services. The demands for hardware and availability are particular to that segment. We have three people responsible for installation, maintenance, and administration.

Deployment is simple if you have been using the solution for a long time. However, it can be complex if you are new to it. 

The initial setup is straightforward because it is well-documented. The deployment time depends on the application. A small application can take around 20 minutes.

I am not involved in its deployment and maintenance. We have a separate team with 40 to 50 people around the globe for that.

We most probably have both on-premises and cloud deployments on a private cloud, but I am not sure. Our infrastructure services team takes care of that.

My involvement in deployment depends on which systems are being deployed. My organization constantly rolls out new systems via OpenStack, on-premise, or other cloud providers. I help build their base images.

The product’s deployment is pretty straightforward. Everything we build is automated and kicked out from there. Once the base image is built, there's really not much to do.

The initial deployment is easy. I can deploy Red Hat Enterprise Linux myself using a base image within a few minutes both on-prem and in the cloud.

Currently, the emphasis is on on-premises solutions.

Though the solution is deployed on a hybrid cloud, I would say that ninety-eight percent is on-premises, and two percent is on the cloud.

Also, I am running my workloads and applications on the cloud.

Deploying Red Hat Enterprise Linux is mostly straightforward, but it depends on your requirements and the settings you need to apply. We typically do everything in-house. Red Hat Enterprise Linux requires a little maintenance. We need to do patching, clean up the file system, rotate logs, etc. 

The setup is straightforward from the operating system side. 

Installing applications and other software can be a bit complex because you need to first determine which packages are required. Once that step is completed, installation is fine. 

It is sometimes a mystery whether vendors support or license their products for a specific version of the solution. Generally, vendors are a few versions behind. For example, some do not support RHEL 8 and none support version RHEL 9. It is not easy, but the solution should work with big vendors and convince them to license new versions right away. 

It was already existing when I joined. I worked with the infrastructure group to maintain and apply fix packs and updates to the Red Hat software.

It does require maintenance. It requires doing fix packs and upgrades. There are some upgrades that are scheduled by Red Hat. It's not maintenance-free.

Setting up Red Hat is straightforward if you're doing a basic installation. They have a beautiful installer that handles everything. For a more advanced deployment, you may need to go through some more complicated steps to customize it for everyone's best practices. 

You only need one person to handle the installation, which takes anywhere from a few minutes to an hour, depending on the installation. If you install Red Hat correctly based on your requirements, you don't need to perform any maintenance. You might need to patch, upgrade, add resources or harden the OS. When discussing security, you always need to follow up on patching and security hardening.

The deployment is straightforward because we use Ansible automation to spin up a new system and install applications directly from the Ansible workflow. We were planning to have Red Hat Enterprise Linux 8 online last year, but Red Hat Enterprise Linux 9 came out, so we decided to wait for a bit, and we're almost ready to upgrade to Red Hat Enterprise Linux 9.  The application folks still haven't had enough time and money to migrate everything over, and we need a project manager. 

We're quite experienced with the initial setup at this point. For us, the process is a standard procedure.

The product does require some maintenance. There are about four people dedicated to the technology at this time.  

It's straightforward. It's pretty easy to deploy Red Hat Enterprise Linux. It can be difficult based on the workflow of the client, but overall, it's pretty straightforward to deploy on the cloud environment because all cloud providers support the deployment of Red Hat Enterprise Linux. The golden image of Red Hat Enterprise Linux is compatible with every cloud provider. There is a feature in the cloud console for joining the Red Hat Enterprise Linux account with the cloud account, so you can create cloud images from the console. It's pretty easy from that.

It's getting better and better. In the past, versions 3 and 4 were very complex, but now, it's very easy to do it. We are now creating images and deploying it on our VMware farms, and it's much easier than making a PXE boot from our bare metal systems. 

The initial setup of RHEL is very straightforward. It's all menu-driven and most of the time there are only a few answers that need to be given during the setup procedure to get a system up and fully running in a few minutes.

We can get a system up and running in about 15 or 20 minutes if we need to. We can do a custom build and use the full build process, or sometimes we do virtual cloning and then just run scripts to individualize the machines.

RHEL's single subscription and install repository for all types of systems may be a bit of a stumbling point. It seems that the descriptions of the subscriptions change every year or two and it gets a little complicated. And the naming conventions they use in the subscriptions can be a little complicated.

As for maintenance and administration of RHEL, there are just two people in our organization who handle that, me and another engineer.

The initial setup is straightforward. In the past, it was complex when Red Hat acquired Ansible because many of the modules were community resources that lacked full support. As a result, creating a playbook to deploy the OS was a painful process, as there was a chance it would not work, and we would not have the necessary support. However, currently, deploying Red Hat Enterprise Linux is easy. We have never deployed only one operating system at a time, but it would take less than one hour to do so.

The deployment is straightforward. 

Building out a server or building out infrastructure is simple, comparatively. Setting it up so that you can deploy multiple servers is simple. Being able to do post-install and install via Ansible is great. It's smooth.

We've been rolling out new OSs across the entire infrastructure at the scale of maybe a year or two. That said, we're getting it ready to deploy everything in a month or two, at a maximum.

There is some maintenance. For example, we have to patch all the time, however, that's true of any product. I am constantly tweaking and upgrading and making changes. That said, in terms of knocking out the foundation, I don't have to do that often, so that's good.

The initial setup was fairly straightforward. We put in the satellite server and then ran the config on each of the nodes to tell them where it was. After that, the updates were happening and there wasn't anything else to be done.

We did not use a formal approach for our implementation and deployment. It was probably more haphazard than structured.

When I order a server in our organization, it comes installed, and then they spin it up.

I am involved in the upgrade processes. The upgrades weren't complex but required some downtime. We don't normally upgrade until a particular OS version becomes end-of-life and the new one starts.

The initial setup is straightforward for our use case. As long as you understand what you're doing, the technologies that are involved, the proper way to style, secure, and prepare them, everything will be fine.

After you have the guide, the printed procedure, the deployment is straightforward. The operating system can be deployed in less than an hour.

Okay, and how long did the deployment take?

Since I've been deploying Red Hat Enterprise Linux for so long, it's not complex for me. Once we configure our kick start, we power up a new system, attach it, and it builds it.

The initial setup can be complex in certain cases, particularly when dealing with a fed customer that operates in an isolated environment. But, in other installations, it has been mostly straightforward. Red Hat Enterprise Linux could still work on making it a little more streamlined in terms of deployment.

There have been some issues we've had with portability, picking it up and moving it somewhere else.

In terms of simplifying risk reduction and maintaining compliance, Red Hat Enterprise Linux is good. The customers I work with don't use them extensively. However, during the machine building process, we apply some security features at build time rather than later on. We take measures such as applying a stake during the build process. While I keep pushing the customers to use the provided tools, some of them operate in air-gapped environments, preventing them from accessing the internet for the latest rules.

The portability of applications and containers built on Red Hat Enterprise Linux is pretty good. We actually build applications on one platform and successfully deploy them on another, so that's pretty good. Overall, using Red Hat Enterprise Linux is definitely a strong set for my customers.

I supported those involved in the setup phase peripherally.

The initial setup was straightforward.

Regarding the straightforward setup, building the base image and deploying it with our internal security standards was pretty straightforward.

The deployment is very easy for me because my organization has been doing it for a long time.

In terms of the deployment model, we have a private cloud. We have VMware for virtualization and Azure Stack for the private cloud. There are also public clouds, such as GCP, AWS, and Azure, and then there is the physical hardware. Some of our deployments are on physical hardware. So, we deploy RHEL on physical servers, and then, there's also the hybrid model when some clients want to integrate the private cloud and the public cloud together. They want the public cloud to be like a backup environment, or they want the private cloud to be a backup environment.

I was mostly involved in the deployment of the hardware and the private cloud.  I was also a part of the team that set up the hybrid environment, but I didn't do a lot of work on the public cloud side. The only complex part of the deployment was the hybrid configuration, where we were trying to interconnect the private cloud and the public cloud. The deployment on the public cloud was more straightforward than the deployment on the private cloud because, on a public cloud, the image is already there, whereas, on a private cloud, you have to set the image up yourself.

Each deployment model took approximately one week to deploy, but the hybrid model, requiring interconnecting the private and public clouds, took more than a week because there were a lot of dependencies.

In terms of maintenance, it does require maintenance. That's the main reason why people pay for support. 

We are all on-prem, but we also have some footprints in AWS but those images are also on Red Hat Enterprise Linux.

Red Hat Enterprise Linux has supported our hybrid cloud strategy. We have a few things running on AWS. We have a few things on OpenShift. We are able to get all the basic images. It is easy to start and deploy anywhere.

One thing I like is the updates because when we patch it and upgrade it, we save a lot of time doing those upgrades and migrations.

Moreover, upgrades or migration to Red Hat Enterprise Linux have been straightforward in some ways. For example, we are currently migrating to Red Hat Enterprise Linux 8 and we have all our servers running on RHEL 7. We have scripts that are very easy to migrate.

For our implementation strategy, we go environment by environment. We start with our development environment. Once we are done with it, we test it. We have some automation test suites, test them, and we go to the upper environment.  

I am a part of the team that does the OS deployment. Its initial deployment is straightforward. We use automation for deployment. We have a kickstart to deploy the OS. Once we create that kickstart configuration file, the deployment is straightforward.

In terms of our upgrade and migration plans to stay current, we upgrade it before the OS is end of life. It is pretty straightforward. We are pretty satisfied with Red Hat Enterprise Linux systems when it comes to provisioning and patching.

It was pretty much straightforward. Deployment of the Red Hat Enterprise Linux operating system didn't take longer than two days.

The initial setup is as straightforward as it can get for anyone who knows what they are talking about. It does require technical knowledge, because that's what it is: a technical solution. It is not something that I would give to my mother. Contrary to other people's perception of, "My mom had a problem with her Windows. Oh, put her on Linux." Yeah, no thanks. Give her a tablet, please. Tablets are pretty cool for non-techies, and even for techies to a certain extent. 

For the migration from AIX, Ansible has been our savior. You do need somebody who knows Ansible, then it is more about printing your servers. So, you press on the print button, then you give it to the apps guys, but you do have to know what you are trying to aim for so the guy who is creating the Ansible Playbook codes exactly what is required with the right variables. After that, it is just a question of shoving that into production. It is pretty wonderful.

The setup was quite straightforward. It was a bit harder with the latest version, but that was because of our VMware version.

For us, deployment takes about 15 to 20 minutes. Most of the time we get someone who orders it. They want to have a website and they need a server and we will spin up a RHEL server for them in our VMware infrastructure.

For deployment and maintenance there are two of us in the company. I'm one of them, in my role as a systems analyst, and my colleague is an IT strategist, although he mainly works as a system admin as well.

The solution's initial setup process is straightforward. You have to follow the steps, copy the template and multiply it.

It's best in terms of security features. We configure the templates and then we implement the CIS controls, security features, and complete patching of the server.

In terms of maintenance, Red Hat provides us with the details about the security vulnerabilities, and the engineer needs to implement all the security on the servers.

The initial setup is very straightforward. It's pretty easy to enable it. After weeks of setting up a Linux Kickstart, the whole system can be deployed. The whole bare-metal system can be deployed in around thirty minutes. So it's really fast, especially for a bare-metal image with a lot of packages installed.

When it comes to maintaining compliance, I think it's pretty good. However, for risk reduction, we have to rely on other software and tools. So I can't really say that Red Hat provides that specific functionality for us. But I think it's good for maintaining compliance is very easy, especially with satellite. It makes it easy for us to access package and vulnerability information, allowing us to identify and resolve any issues. Overall, it works quite well. If you use the right products, I believe you can have all the necessary components in one place.

The portability of applications and containers is pretty good, although there is one issue. With the transition to Red Hat 8, Docker was removed. As a result, there is an issue with using Podman, specifically related to certain types of authentication in a mixed Windows-Linux environment. Due to the way secrets and related functionalities work, Podman cannot be utilized in that scenario. Therefore, there are some challenges to address in this regard.

I believe Red Hat should have maintained compatibility with Docker or at least their own Red Hat Docker until they could bring their software up to speed.

Deployment is easy. It's very intuitive and it is well explained in the documentation.

The time it takes depends on the application, but the operating system takes a few hours to deploy and do the initial configuration. In two hours you can have a system up and running.

Generally, we start with the requirements. We have a pre-production environment and we test the strategy there. We prefer container applications, so one of the strategies that we follow is that, if it is possible to install the application container, we do that.

It can be deployed by one person like me. I am an architect but I could be a system engineer certified by Red Hat. The solution requires maintenance such as periodic upgrades to stay up to date. We have two or three people involved in that process, including patching application, compiling the product, and updating the application and the operating system, when needed to stay current and to be compatible with the next new features.

We have deployed it in various locations and we have also deployed it in IBM Power Systems as well as in some databases. We have an application server installed there and some IBM applications.

I was involved in the deployment. The initial setup was very straightforward.

The deployment is fast and the process is efficient. 

We have deployed Red Hat on-prem on Hyper-V. We've also deployed Red Hat on-prem on VMware, and we also have Red Hat on Azure Cloud. In terms of version, we have everything from 7.2 and all the way to 7.6. We currently don't have any real deployment of version 8 or version 9.

I'm the person who does most of the deployments. The deployment is quite easy. I'd rate it an eight out of ten in terms of the ease of deployment. Deploying Red Hat would be quite easy even for a beginner system administrator because it guides you during the deployment. It asks you whether you want to use a feature or what features you want to install alongside the operating system. Do you want a file server, or do you want a web server? The installation is quite straightforward and simple.

For me, normally the complete configuration from deploying the OS and managing storage, users, and security takes less than 30 minutes. In less than 30 minutes, I'm usually up and running.

The deployment of Red Hat Enterprise Linux was initially complex because we were not aware of all the available tools to streamline the process. We had to learn, but now we are more proficient. 

Tasks that once took a month can now be completed in a week. We worked directly with Red Hat Enterprise Linux, without an integrated reseller or consultant.

The solution's initial setup involves initial hiccups going back and forth to the requirements and the architecture, but so far, so good.

Red Hat Enterprise Linux’s initial setup is pretty straightforward.

I was involved in the deployment a long time ago. The setup process is easy. The solution is also easy to use.

Regarding the time taken for deployment, we can do it with a machine at this moment using Ansible. In our orchestration, we passed more or less, creating one machine for Red Hat and the entire environment. It took us eight days and an hour. At this moment, we can deploy it on a machine in an hour with all the security. If a developer comes to us and tells us that they need a new machine or new instance, we can provide that in an hour on-premises. In the cloud, we have to use a lot of tools.

The initial setup is mostly straightforward depending on the specific setup. We build our own containers and that is more complex but there are simplex supported setups. In both scenarios, maintenance only involves a few commands and is simple. It is maintained by two security engineers. 

Upgrades and migrations are easy with Red Hat Enterprise Linux. We are currently working on upgrades from RHEL 7 to RHEL 9.

The initial deployment is straightforward and well-documented. The deployment time is between 15 to 30 minutes.

Typically, the initial setup is pretty straightforward. If it's virtualization, it is really easy because we have an image already, or we can create one. We can use Kickstart. I used to run a 5000-node HPC cluster in the early 2000s based on Red Hat Enterprise Linux. We used a combination of SystemImager and Kickstart for it.

Since I've been working with Red Hat Enterprise Linux for a long time, it feels easy for me. However, for someone completely new to it, especially coming from a Windows background, it might seem more complicated. But for me, it's second nature and not that difficult. So the initial setup depends on the level of familiarity with the system.

For a brand-new system, it might take around ten minutes.

The setup of RHEL is straightforward, there is nothing complex about it. Everything is well documented on their website.

The product's deployment is straightforward. 

It's on-prem right now. The deployment was straightforward. 

I manage the infrastructure team so all of these things are under my purview. 

We did hit some hiccups, but then RHEL's emergency support was available, and we were able to resolve it. 

We do a template, and then we just use it. It's quite great.

We are using Satellite, which is considered to be a subscription manager, in a way. In the beginning, it was complicated. Now, they have created something called Simple Content Access  (SCA). We buy a subscription for audit purposes and for legality to have a legitimate copy. On the other hand, Satellite itself issues subscriptions once you have a new OS system. That has made things way easier.

RHEL provides features that help speed our deployment. Installing on a physical server takes more time than installing it onto a virtual machine (VM).

Because of absence of local support in our part of the region, we did find some difficulties in the initial deployments with hardware vendors/ partners when we started in 2003. The local partners didn't have much knowledge of Linux environments at that time, and the support for hardware was also a bit tricky. The deployment took a couple of days until we got support from the hardware manufacturer.

Nowadays, it's very good. I managed to get good support from the hardware vendors after that incident.

We have our own deployment plans for the operating systems that include some baseline configurations and security checklists.

I was involved in the deployment or setup of RHEL to a degree, but it was mostly during our life cycle refreshes when we moved from RHEL 6 to RHEL 7 to RHEL 8. And now, we're looking at RHEL 9. 

On the backend development of the base image, I'm part of the team that puts together the base design, and then we put the steps into our repository so that we can rebuild the images easier. Right now, it's a manual process. We want to get to the point where we have all of the changes documented in a GitHub solution or something where we can make a change, push a button and have it implement those changes in there by using a script or something else. I'm mostly the one yelling to the Linux developers to get their stuff done because they have a tendency to run multiple instances while they're transitioning. They'll run an RHEL 6 box, an RHEL 7 box, and an RHEL 8 box at the same time when they have to get off of RHEL 6 and RHEL 7. So, I'm more of the management yelling at them to get this stuff done.

The initial setup was straightforward because I'd already had some experience with Linux. Even without experience implementation is relatively easy. Deployment time depends on the project and usually takes longer with android applications because the deployment is not one process. We usually deploy on cloud, sometimes private and sometimes public. 

I was only involved in testing this solution during the deployment process. During testing, it was easy to make changes to configurations which also support our decision to use Red Hat. 

When setting up any Linux environment, make sure you understand how the LVM works. Other than that it was all fairly straight-forward.

The initial setup is easy, it takes around 10-15 minutes. 

It was straightforward. Our deployments are automated. To deploy a build internally, it only takes half an hour, but that's usually in automation. It would probably take a couple of months to put the infrastructure in place to be able to deploy it.

Easy. Used Kickstart to automate installation and post install config.

The deployment is actually okay. It is not too easy and not too complex. It is easy for experienced people, but if you don't have the experience, it can be a little hard. 

The deployment duration depends on the type of deployment that we are doing. It could take from a day to a week or two weeks. We can also use Jenkins for auto-deployment.

No.