#spring boot mysql kubernetes example

[freshparadisepaper]

Software Engineer Resume Examples That Land 6-Figure Jobs

Introduction: Why Your Resume Is Your First Line of Code

When it comes to landing a 6-figure software engineering job, your resume isn’t just a document—it’s your personal algorithm for opportunity.

Recruiters spend an average of 6–8 seconds on an initial resume scan, meaning you have less time than a function call to make an impression. Whether you're a backend expert, front-end developer, or full-stack wizard, structuring your resume strategically can mean the difference between “Interview scheduled” and “Application rejected.”

This guide is packed with real-world engineering resume examples and data-backed strategies to help you craft a resume that breaks through the noise—and lands you the role (and salary) you deserve.

What Makes a Software Engineer Resume Worth 6 Figures?

Before diving into examples, let's outline the key ingredients that top-tier employers look for in high-paying engineering candidates:

Clear technical specialization (e.g., front-end, DevOps, cloud)

Strong project outcomes tied to business value

Demonstrated leadership or ownership

Modern, ATS-friendly formatting

Tailored content for the job role

According to LinkedIn’s 2024 Emerging Jobs Report, software engineers with cloud, AI/ML, and DevOps experience are the most in-demand, with average salaries exceeding $120,000 annually in the U.S.

Structuring the Perfect Software Engineer Resume

Here’s a proven framework used in many successful engineering resume examples that landed six-figure jobs:

1. Header and Contact Information

Keep it clean and professional. Include:

Full name

Email (professional)

GitHub/Portfolio/LinkedIn URL

Phone number

2. Professional Summary (3–4 Lines)

Use this space to summarize your experience, key technologies, and what makes you stand out.

Example: "Full-stack software engineer with 7+ years of experience building scalable web applications using React, Node.js, and AWS. Passionate about clean code, continuous delivery, and solving real-world business problems."

3. Technical Skills (Grouped by Category)

Format matters here—grouping helps recruiters scan quickly.

Languages: JavaScript, Python, Java

Frameworks: React, Django, Spring Boot

Tools/Platforms: Git, Docker, AWS, Kubernetes, Jenkins

Databases: MySQL, MongoDB, PostgreSQL

4. Experience (Show Impact, Not Just Tasks)

Use action verbs + quantifiable results + technologies used.

Example:

Designed and implemented a microservices architecture using Spring Boot and Docker, improving system uptime by 35%.

Migrated legacy systems to AWS, cutting infrastructure costs by 25%.

Led a team of 4 engineers to launch a mobile banking app that acquired 100,000+ users in 6 months.

5. Education

List your degree(s), university name, and graduation date. If you're a recent grad, include relevant coursework.

6. Projects (Optional but Powerful)

Projects are crucial for junior engineers or those transitioning into tech. Highlight the challenge, your role, the tech stack, and outcomes.

Real-World Engineering Resume Examples (For Inspiration)

Example 1: Backend Software Engineer Resume (Mid-Level)

Summary: Backend developer with 5+ years of experience in building RESTful APIs using Python and Django. Focused on scalable architecture and robust database design.

Experience:

Developed a REST API using Django and PostgreSQL, powering a SaaS platform with 10k+ daily users.

Implemented CI/CD pipelines with Jenkins and Docker, reducing deployment errors by 40%.

Skills: Python, Django, PostgreSQL, Git, Docker, Jenkins, AWS

Why It Works: It’s direct, results-focused, and highlights technical depth aligned with backend engineering roles.

Example 2: Front-End Engineer Resume (Senior Level)

Summary: Senior front-end developer with 8 years of experience crafting responsive and accessible web interfaces. Strong advocate of performance optimization and user-centered design.

Experience:

Led UI redevelopment of an e-commerce platform using React, increasing conversion rate by 22%.

Integrated Lighthouse audits to enhance Core Web Vitals, resulting in 90+ scores across all pages.

Skills: JavaScript, React, Redux, HTML5, CSS3, Webpack, Jest

Why It Works: Focuses on user experience, performance metrics, and modern front-end tools—exactly what senior roles demand.

Example 3: DevOps Engineer Resume (6-Figure Role)

Summary: AWS-certified DevOps engineer with 6 years of experience automating infrastructure and improving deployment pipelines for high-traffic platforms.

Experience:

Automated infrastructure provisioning using Terraform and Ansible, reducing setup time by 70%.

Optimized Kubernetes deployment workflows, enabling blue-green deployments across services.

Skills: AWS, Docker, Kubernetes, Terraform, CI/CD, GitHub Actions

Why It Works: It highlights automation, scalability, and cloud—all high-value skills for 6-figure DevOps roles.

ATS-Proofing Your Resume: Best Practices

Applicant Tracking Systems are a major hurdle—especially in tech. Here’s how to beat them:

Use standard headings like “Experience” or “Skills”

Avoid tables, columns, or excessive graphics

Use keywords from the job description naturally

Save your resume as a PDF unless instructed otherwise

Many successful candidates borrow formatting cues from high-performing engineering resume examples available on reputable sites like GitHub, Resume.io, and Zety.

Common Mistakes That Can Cost You the Job

Avoid these pitfalls if you’re targeting 6-figure roles:

Listing outdated or irrelevant tech (e.g., Flash, VBScript)

Using vague responsibilities like “worked on the website”

Failing to show impact or metrics

Forgetting to link your GitHub or portfolio

Submitting the same resume to every job

Each job should have a slightly tailored resume. The effort pays off.

Bonus Tips: Add a Competitive Edge

Certifications: AWS, Google Cloud, Kubernetes, or relevant coding bootcamps

Contributions to open source projects on GitHub

Personal projects with real-world use cases

Blog or technical writing that demonstrates thought leadership

Conclusion: Turn Your Resume Into a Career-Launching Tool

Crafting a winning software engineer resume isn’t just about listing skills—it’s about telling a compelling story of how you create value, solve problems, and ship scalable solutions.

The best engineering resume examples strike a perfect balance between clarity, credibility, and customization. Whether you're a bootcamp grad or a seasoned engineer, investing time into your resume is one of the highest ROI career moves you can make.

👉 Visit our website for professionally designed templates, expert tips, and more examples to help you land your dream role—faster.

[codecraftshop]

Deploy Springboot mysql application on Openshift

Deploy Springboot mysql application on Openshift

#openshift #openshift4 #springbootmysql #mysqlconnectivity #SpringbootApplicationWithMysql

Deploy Springboot mysql application on Openshift,spring boot with mysql on k8s,openshift deploy spring boot jar,spring boot java with mysql on kubernetes,spring boot mysql kubernetes example,spring boot with mysql on kubernetes,deploy web…

[itbeatsbookmarks]

(Via: Hacker News)

Today’s developers are expected to develop resilient and scalable distributed systems. Systems that are easy to patch in the face of security concerns and easy to do low-risk incremental upgrades. Systems that benefit from software reuse and innovation of the open source model. Achieving all of this for different languages, using a variety of application frameworks with embedded libraries is not possible.

Recently I’ve blogged about “Multi-Runtime Microservices Architecture” where I have explored the needs of distributed systems such as lifecycle management, advanced networking, resource binding, state abstraction and how these abstractions have been changing over the years. I also spoke about “The Evolution of Distributed Systems on Kubernetes” covering how Kubernetes Operators and the sidecar model are acting as the primary innovation mechanisms for delivering the same distributed system primitives.

On both occasions, the main takeaway is the prediction that the progression of software application architectures on Kubernetes moves towards the sidecar model managed by operators. Sidecars and operators could become a mainstream software distribution and consumption model and in some cases even replace software libraries and frameworks as we are used to.

The sidecar model allows the composition of applications written in different languages to deliver joint value, faster and without the runtime coupling. Let’s see a few concrete examples of sidecars and operators, and then we will explore how this new software composition paradigm could impact us.

Out-of-Process Smarts on the Rise

In Kubernetes, a sidecar is one of the core design patterns achieved easily by organizing multiple containers in a single Pod. The Pod construct ensures that the containers are always placed on the same node and can cooperate by interacting over networking, file system or other IPC methods. And operators allow the automation, management and integration of the sidecars with the rest of the platform. The sidecars represent a language-agnostic, scalable data plane offering distributed primitives to custom applications. And the operators represent their centralized management and control plane.

Let’s look at a few popular manifestations of the sidecar model.

Envoy

Service Meshes such as Istio, Consul, and others are using transparent service proxies such as Envoy for delivering enhanced networking capabilities for distributed systems. Envoy can improve security, it enables advanced traffic management, improves resilience, adds deep monitoring and tracing features. Not only that, it understands more and more Layer 7 protocols such as Redis, MongoDB, MySQL and most recently Kafka. It also added response caching capabilities and even WebAssembly support that will enable all kinds of custom plugins. Envoy is an example of how a transparent service proxy adds advanced networking capabilities to a distributed system without including them into the runtime of the distributed application components.

Skupper

In addition to the typical service mesh, there are also projects, such as Skupper, that ship application networking capabilities through an external agent. Skupper solves multicluster Kubernetes communication challenges through a Layer 7 virtual network and offers advanced routing and connectivity capabilities. But rather than embedding Skupper into the business service runtime, it runs an instance per Kubernetes namespace which acts as a shared sidecar.

Cloudstate

Cloudstate is another example of the sidecar model, but this time for providing stateful abstractions for the serverless development model. It offers stateful primitives over GRPC for EventSourcing, CQRS, Pub/Sub, Key/Value stores and other use cases. Again, it an example of sidecars and operators in action but this time for the serverless programming model.

Dapr

Dapr is a relatively young project started by Microsoft, and it is also using the sidecar model for providing developer-focused distributed system primitives. Dapr offers abstractions for state management, service invocation and fault handling, resource bindings, pub/sub, distributed tracing and others. Even though there is some overlap in the capabilities provided by Dapr and Service Mesh, both are very different in nature. Envoy with Istio is injected and runs transparently from the service and represents an operational tool. Dapr, on the other hand, has to be called explicitly from the application runtime over HTTP or gRPC and it is an explicit sidecar targeted for developers. It is a library for distributed primitives that is distributed and consumed as a sidecar, a model that may become very attractive for developers consuming distributed capabilities.

Camel K

Apache Camel is a mature integration library that rediscovers itself on Kubernetes. Its subproject Camel K uses heavily the operator model to improve the developer experience and integrate deeply with the Kubernetes platform. While Camel K does not rely on a sidecar, through its CLI and operator it is able to reuse the same application container and execute any local code modification in a remote Kubernetes cluster in less than a second. This is another example of developer-targeted software consumption through the operator model.

More to Come

And these are only some of the pioneer projects exploring various approaches through sidecars and operators. There is more work being done to reduce the networking overhead introduced by container-based distributed architectures such as the data plane development kit (DPDK), which is a userspace application that bypasses the layers of the Linux kernel networking stack and access directly to the network hardware. There is work in the Kubernetes project to create sidecar containers with more granular lifecycle guarantees. There are new Java projects based on GraalVM implementation such as Quarkus that reduce the resource consumption and application startup time which makes more workloads attractive for sidecars. All of these innovations will make the side-car model more attractive and enable the creation of even more such projects.

Sidecars providing distributed systems primitives

I’d not be surprised to see projects coming up around more specific use cases such as stateful orchestration of long-running processes such as Business Process Model and Notation (BPMN) engines in sidecars. Job schedulers in sidecars. Stateless integration engines i.e. Enterprise Integration Patterns implementations in sidecars. Data abstractions and data federation engines in sidecars. OAuth2/OpenID proxy in sidecars. Scalable database connection pools for serverless workloads in sidecars. Application networks as sidecars, etc. But why would software vendors and developers switch to this model? Let’s see a few of the benefits it provides.

Runtimes with Control Planes over Libraries

If you are a software vendor today, probably you have already considered offering your software to potential users as an API or a SaaS-based solution. This is the fastest software consumption model and a no-brainer to offer, when possible. Depending on the nature of the software you may be also distributing your software as a library or a runtime framework. Maybe it is time to consider if it can be offered as a container with an operator too. This mechanism of distributing software and the resulting architecture has some very unique benefits that the library mechanism cannot offer.

Supporting Polyglot Consumers

By offering libraries to be consumable through open protocols and standards, you open them up for all programming languages. A library that runs as a sidecar and consumable over HTTP, using a text format such as JSON does not require any specific client runtime library. Even when gRPC and Protobuf are used for low-latency and high-performance interactions, it is still easier to generate such clients than including third party custom libraries in the application runtime and implement certain interfaces.

Application Architecture Agnostic

The explicit sidecar architecture (as opposed to the transparent one) is a way of software capability consumption as a separate runtime behind a developer-focused API. It is an orthogonal feature that can be added to any application whether that is monolithic, microservices, functions-based, actor-based or anything in between. It can sit next to a monolith in a less dynamic environment, or next to every microservice in a dynamic cloud-based environment. It is trivial to create sidecars on Kubernetes, and doable on many other software orchestration platforms too.

Tolerant to Release Impedance Mismatch

Business logic is always custom and developed in house. Distributed system primitives are well-known commodity features, and consumed off-the-shelf as either platform features or runtime libraries. You might be consuming software for state abstractions, messaging clients, networking resiliency and monitoring libraries, etc. from third-party open source projects or companies. And these third party entities have their release cycles, critical fixes, CVE patches that impact your software release cycles too. When third party libraries are consumed as a separate runtime (sidecar), the upgrade process is simpler as it is behind an API and it is not coupled with your application runtime. The release impedance mismatch between your team and the consumed 3rd party libraries vendors becomes easier to manage.

Control Plane Included Mentality

When a feature is consumed as a library, it is included in your application runtime and it becomes your responsibility to understand how it works, how to configure, monitor, tune and upgrade. That is because the language runtimes (such as the JVM) and the runtime frameworks (such as Spring Boot or application servers) dictate how a third-party library can be included, configured, monitored and upgraded. When a software capability is consumed as a separate runtime (such as a sidecar or standalone container) it comes with its own control plane in the form of a Kubernetes operator.

That has a lot of benefits as the control plane understands the software it manages (the operand) and comes with all the necessary management intelligence that otherwise would be distributed as documentation and best practices. What’s more, operators also integrate deeply with Kubernetes and offer a unique blend of platform integration and operand management intelligence out-of-the-box. Operators are created by the same developers who are creating the operands, they understand the internals of the containerized features and know how to operate the best. Operators are executables SREs in containers, and the number of operators and their capabilities are increasing steadily with more operators and marketplaces coming up.

Software Distribution and Consumption in the Future

Software Distributed as Sidecars with Control Planes

Let’s say you are a software provider of a Java framework. You may distribute it as an archive or a Maven artifact. Maybe you have gone a step further and you distribute a container image. In either case, in today’s cloud-native world, that is not good enough. The users still have to know how to patch and upgrade a running application with zero downtime. They have to know what to backup and restore its state. They have to know how to configure their monitoring and alerting thresholds. They have to know how to detect and recover from complex failures. They have to know how to tune an application based on the current load profile.

In all of these and similar scenarios, intelligent control planes in the form of Kubernetes operators are the answer. An operator encapsulates platform and domain knowledge of an application in a declaratively configured component to manage the workload.

Sidecars and operators could become a mainstream software distribution and consumption model and in some cases even replace software libraries and frameworks as we are used to.

Let’s assume that you are providing a software library that is included in the consumer applications as a dependency. Maybe it is the client-side library of the backend framework described above. If it is in Java, for example, you may have certified it to run it on a JEE server, provided Spring Boot Starters, Builders, Factories, and other implementations that are all hidden behind a clean Java interface. You may have even backported it to .Net too.

With Kubernetes operators and sidecars all of that is hidden from the consumer. The factory classes are replaced by the operator, and the only configuration interface is a YAML file for the custom resource. The operator is then responsible for configuring the software and the platform so that users can consume it as an explicit sidecar, or a transparent proxy. In all cases, your application is available for consumption over remote API and fully integrated with the platform features and even other dependent operators. Let’s see how that happens.

Software Consumed over Remote APIs Rather than Embedded Libraries

One way to think about sidecars is similar to the composition over inheritance principle in OOP, but in a polyglot context. It is a different way of organizing the application responsibilities by composing capabilities from different processes rather than including them into a single application runtime as dependencies. When you consume software as a library, you instantiate a class, call its methods by passing some value objects. When you consume it as an out-of-process capability, you access a local process. In this model, methods are replaced with APIs, in-process methods invocation with HTTP or gRPC invocations, and value objects with something like CloudEvents. This is a change from application servers to Kubernetes as the distributed runtime. A change from language-specific interfaces, to remote APIs. From in-memory calls to HTTP, from value objects to CloudEvents, etc.

This requires software providers to distribute containers and controllers to operate them. To create IDEs that are capable of building and debugging multiple runtime services locally. CLIs for quickly deploying code changes into Kubernetes and configuring the control planes. Compilers that can decide what to compile in a custom application runtime, what capabilities to consume from a sidecar and what from the orchestration platform.

Software consumers and providers ecosystem

In the longer term, this will lead to the consolidation of standardized APIs that are used for the consumption of common primitives in sidecars. Rather than language-specific standards and APIs we will have polyglot APIs. For example, rather than Java Database Connectivity (JDBC) API, caching API for Java (JCache), Java Persistence API (JPA), we will have polyglot APIs over HTTP using something like CloudEvents. Sidecar centric APIs for messaging, caching, reliable networking, cron jobs and timer scheduling, resource bindings (connectors to other APIs, protocols), idempotency, SAGAs, etc. And all of these capabilities will be delivered with the management layer included in the form of operators and even wrapped with self-service UIs. The operators are key enablers here as they will make this even more distributed architecture easy to manage and self-operate on Kubernetes. The management interface of the operator is defined by the CustomResourceDefinition and represents another public-facing API that remains application-specific.

This is a big shift in mentality to a different way of distributing and consuming software, driven by the speed of delivery and operability. It is a shift from a single runtime to multi runtime application architectures. It is a shift similar to what the hardware industry had to go through from single-core to multicore platforms when Moore’s law ended. It is a shift that is slowly happening by building all the elements of the puzzle: we have uniformly adopted and standardized containers, we have a de facto standard for orchestration through Kubernetes, possibly improved sidecars coming soon, rapid operators adoption, CloudEvents as a widely agreed standard, light runtimes such as Quarkus, etc. With the foundation in place, applications, productivity tools, practices, standardized APIs, and ecosystem will come too.

This post was originally published at ​The New Stack here.

[learning-code-ficusoft]

A Guide to Creating APIs for Web Applications

APIs (Application Programming Interfaces) are the backbone of modern web applications, enabling communication between frontend and backend systems, third-party services, and databases. In this guide, we’ll explore how to create APIs, best practices, and tools to use.

1. Understanding APIs in Web Applications

An API allows different software applications to communicate using defined rules. Web APIs specifically enable interaction between a client (frontend) and a server (backend) using protocols like REST, GraphQL, or gRPC.

Types of APIs

RESTful APIs — Uses HTTP methods (GET, POST, PUT, DELETE) to perform operations on resources.

GraphQL APIs — Allows clients to request only the data they need, reducing over-fetching.

gRPC APIs — Uses protocol buffers for high-performance communication, suitable for microservices.

2. Setting Up a REST API: Step-by-Step

Step 1: Choose a Framework

Node.js (Express.js) — Lightweight and popular for JavaScript applications.

Python (Flask/Django) — Flask is simple, while Django provides built-in features.

Java (Spring Boot) — Enterprise-level framework for Java-based APIs.

Step 2: Create a Basic API

Here’s an example of a simple REST API using Express.js (Node.js):javascriptconst express = require('express'); const app = express(); app.use(express.json());let users = [{ id: 1, name: "John Doe" }];app.get('/users', (req, res) => { res.json(users); });app.post('/users', (req, res) => { const user = { id: users.length + 1, name: req.body.name }; users.push(user); res.status(201).json(user); });app.listen(3000, () => console.log('API running on port 3000'));

Step 3: Connect to a Database

APIs often need a database to store and retrieve data. Popular databases include:

SQL Databases (PostgreSQL, MySQL) — Structured data storage.

NoSQL Databases (MongoDB, Firebase) — Unstructured or flexible data storage.

Example of integrating MongoDB using Mongoose in Node.js:javascriptconst mongoose = require('mongoose'); mongoose.connect('mongodb://localhost:27017/mydb', { useNewUrlParser: true, useUnifiedTopology: true });const UserSchema = new mongoose.Schema({ name: String }); const User = mongoose.model('User', UserSchema);app.post('/users', async (req, res) => { const user = new User({ name: req.body.name }); await user.save(); res.status(201).json(user); });

3. Best Practices for API Development

🔹 Use Proper HTTP Methods:

GET – Retrieve data

POST – Create new data

PUT/PATCH – Update existing data

DELETE – Remove data

🔹 Implement Authentication & Authorization

Use JWT (JSON Web Token) or OAuth for securing APIs.

Example of JWT authentication in Express.js:

javascript

const jwt = require('jsonwebtoken'); const token = jwt.sign({ userId: 1 }, 'secretKey', { expiresIn: '1h' });

🔹 Handle Errors Gracefully

Return appropriate status codes (400 for bad requests, 404 for not found, 500 for server errors).

Example:

javascript

app.use((err, req, res, next) => { res.status(500).json({ error: err.message }); });

🔹 Use API Documentation Tools

Swagger or Postman to document and test APIs.

4. Deploying Your API

Once your API is built, deploy it using:

Cloud Platforms: AWS (Lambda, EC2), Google Cloud, Azure.

Serverless Functions: AWS Lambda, Vercel, Firebase Functions.

Containerization: Deploy APIs using Docker and Kubernetes.

Example: Deploying with DockerdockerfileFROM node:14 WORKDIR /app COPY package.json ./ RUN npm install COPY . . CMD ["node", "server.js"] EXPOSE 3000

5. API Testing and Monitoring

Use Postman or Insomnia for testing API requests.

Monitor API Performance with tools like Prometheus, New Relic, or Datadog.

Final Thoughts

Creating APIs for web applications involves careful planning, development, and deployment. Following best practices ensures security, scalability, and efficiency.

WEBSITE: https://www.ficusoft.in/python-training-in-chennai/

[codecraftshop]

Deploy Springboot mysql application on Openshift#openshift #openshift4 #springbootmysql #mysqlconnectivity #SpringbootApplicationWithMysql Deploy Springboot mysql application on Openshift,spring boot with mysql on k8s,openshift deploy spring boot jar,spring boot java with mysql on kubernetes,spring boot mysql kubernetes example,spring boot with mysql on kubernetes,deploy web application in openshift web console,how to deploy spring boot application to google app engine,deploying spring boot in kubernetes,how to deploy application on openshift,openshift deploy java application,openshift,spring boot,red hat https://www.youtube.com/channel/UCnIp4tLcBJ0XbtKbE2ITrwA?sub_confirmation=1&app=desktop About: 00:00 Deploy Springboot mysql application on Openshift In this course we will learn about deploying springboot application with mysql database connectivity in openshift. Red Hat OpenShift is an open source container application platform based on the Kubernetes container orchestrator for enterprise application development and deployment Experience with RedHat OpenShift 4 Container Platform. This course introduces OpenShift to an Absolute Beginner using really simple and easy to understand lectures. What is Openshift online and Openshift dedicated gives administrators a single place to implement and enforce policies across multiple teams, with a unified console across all Red Hat OpenShift clusters. Red Hat is the world's leading provider of enterprise open source solutions, including high-performing Linux, cloud, container, and Kubernetes technologies. you will learn how to develop build and deploy spring boot application with mysql on a kubernetes cluster and also you can learn how to create configmaps and secrets on a kubernetes cluster. building and deploying spring boot application with mysql on kubernetes cluster. Openshift/ Openshift4 a cloud based container to build deploy test our application on cloud. In the next videos we will explore Openshift4 in detail. Commands used in this video : 1. Source code location: https://github.com/codecraftshop/SpringbootOpenshitMysqlDemo.git 2. Expose the service command. oc expose svc/mysql oc describe svc/mysql Openshift related videos: Openshift : 1-Introduction to openshift and why openshift - introduction to openshift https://youtu.be/yeTOjwb7AYU Openshift : 2-Create openshift online account to access openshift cluster https://youtu.be/76N7RQfzm14 Openshift : 3-Introduction to openshift online cluster | overview of openshift online cluster https://youtu.be/od3qCzzIPa4 Openshift : 4-Login to openshift cluster in different ways | openshift 4 https://youtu.be/ZOAs7_1xFNA Openshift : 5-How to deploy web application in openshift web console https://youtu.be/vmDtEn_DN2A Openshift : 6-How to deploy web application in openshift command line https://youtu.be/R_lUJTdQLEg Openshift : 7-Deploy application in openshift using container images https://youtu.be/ii9dH69839o Openshift : 8-Deploy jenkins on openshift cluster - deploy jenkins on openshift | openshift https://youtu.be/976MEDGiPPQ Openshift : 9-Openshift build trigger using openshift webhooks - continuous integration with webhook triggers https://youtu.be/54_UtSDz4SE Openshift : 10-Install openshift 4 on laptop using redhat codeready containers - CRC https://youtu.be/9A05yTSjiFI https://www.facebook.com/codecraftshop/ https://t.me/codecraftshop/ Please do like and subscribe to my you tube channel "CODECRAFTSHOP" Follow us on facebook | instagram | twitter at @CODECRAFTSHOP .