Freelancer DevOps Engineer – GKE / GCP / Virtualization

Project Type: Freelance

Engagement: Project-Based

Duration: As per Project Requirement

Experience: 5-6 years

Project Requirement

We are looking for an experienced Freelance DevOps Engineer with strong hands-on expertise in Google Kubernetes Engine (GKE), Google Cloud Platform (GCP), Kubernetes, virtualization, cloud networking, load balancing, and storage.

The primary responsibility will be to design, configure, deploy, and optimize a GCP/GKE-based setting capable of hosting multiple isolated user OS sessions across six different scenarios.

The solution should be scalable, secure, reliable, and capable of supporting up to 36 concurrent OS sessions.

Key Tasks The freelancer will be responsible for:

- Configure and deploy the required GCP infrastructure.
- Set up and configure Google Kubernetes Engine (GKE).
- Design the Kubernetes architecture for 6 independent scenarios.
- Configure 6 OS sessions per scenario, supporting up to 36 concurrent sessions.
- Determine the appropriate architecture for running full OS/VM sessions.
- Evaluate and recommend the most suitable virtualization approach, such as KubeVirt, Google Compute Engine, or another appropriate solution.
- Configure VM/container resource allocation for CPU, RAM and storage.
- Implement proper user/session isolation between scenarios.
- Configure VPC, subnets, firewall rules, routing and required network access controls.
- Configure secure access to individual OS sessions.
- Configure Google Cloud Load Balancing for distributing and routing user/session traffic.
- Configure Kubernetes Ingress / Gateway / Services as required.
- Ensure appropriate traffic routing between users, scenarios, applications and OS sessions.
- Configure Google Cloud Storage (GCS) for required application data, session data, backups and/or persistent storage.
- Configure appropriate GCS bucket structure, IAM permissions and access controls.
- Implement storage lifecycle policies and optimize storage utilization where required.
- Configure persistent storage using appropriate GCP/Kubernetes storage solutions.
- Implement automated provisioning, allocation, startup, shutdown and termination of OS sessions.
- Configure Kubernetes workloads, services, ingress and other required components.
- Implement autoscaling and resource optimization wherever required.




- Configure monitoring, logging and alerting using Google Cloud Monitoring/Logging and/or Prometheus/Grafana.
- Monitor CPU, RAM, storage, network, VM/session and GKE resource utilization.
- Implement appropriate IAM, RBAC, security policies and access controls.
- Troubleshoot GKE, networking, load balancing, storage, VM and session-related issues.
- Optimize the infrastructure for performance, scalability, reliability and cost efficiency.
- Provide complete technical documentation, deployment procedures and handover documentation.

Important Technical Requirements The freelancer should have practical hands-on experience with:

- Google Cloud Platform (GCP)
- Google Kubernetes Engine (GKE)
- Kubernetes
- Docker / Containerization
- Linux Administration
- Terraform / Infrastructure as Code
- Kubernetes Networking
- GCP VPC & Networking
- GCP IAM
- Google Cloud Load Balancing
- Google Cloud Storage (GCS)
- Kubernetes Ingress / Gateway
- Persistent Storage
- CI/CD
- Cloud Monitoring & Logging
- Bash / Python Scripting

Additional Advantage Experience with the following will be highly preferred:

- KubeVirt
- Kubernetes-based VM orchestration
- Google Compute Engine (GCE)
- Windows/Linux virtualization
- Remote Desktop / OS session environments
- Multi-user / multi-tenant infrastructure
- Persistent VM storage
- High-availability architecture
- Automated VM/session provisioning
- Load balancing and traffic routing
- Cloud cost optimization

Expected Architecture GCP Infrastructure → VPC / Networking / Security → Google Cloud Load Balancer → GKE Cluster → 6 Independent Scenarios → 6 OS Sessions per Scenario → Up to 36 Concurrent OS Sessions

Google Cloud Storage (GCS) will be integrated for required persistent data, session data, application data, backups and/or storage requirements.

The freelancer should be able to recommend and implement the most suitable architecture if GKE alone is not the optimal solution for running the required full OS/VM sessions.





Expected Deliverables

1. Fully configured GCP environment.
2. Working GKE cluster.
3. Six independent scenario environments.
4. Six OS sessions per scenario.
5. Support for up to 36 concurrent OS sessions.
6. Secure user/session access mechanism.
7. Google Cloud Load Balancing configuration.
8. VPC, subnet, firewall and networking configuration.
9. Google Cloud Storage (GCS) configuration.
10. Persistent storage and backup mechanism, wherever required.
11. Automated session provisioning and deprovisioning.
12. Resource allocation and user/session isolation.
13. Autoscaling and resource optimization.
14. Monitoring, logging and alerting.
15. Security configuration including IAM and Kubernetes RBAC.
16. Deployment scripts / Terraform / IaC files.
17. Complete technical documentation.
18. Architecture and deployment diagrams.
19. Testing of all six scenarios and concurrent sessions.
20. Final working demonstration and knowledge transfer.

Freelancer Should Provide The freelancer should provide:

- Relevant GCP/GKE project experience.
- Examples of similar Kubernetes/virtualization projects completed.
- Experience with multi-user or multi-tenant environments.
- Experience with GCP Load Balancing and Google Cloud Storage.
- Proposed architecture and technical approach.
- Recommended virtualization approach for running the required OS sessions.
- Estimated project timeline.
- Fixed project cost or hourly rate.
- Availability for implementation, testing, troubleshooting and handover.
- Post-deployment support, if required.

Ideal Freelancer The ideal freelancer is someone who has actually designed, configured and deployed GCP/GKE-based virtualization or multi-user environments, preferably involving full OS/VM sessions, Kubernetes, load balancing, cloud storage and automated provisioning. Candidates with only theoretical Kubernetes knowledge or basic GCP deployment experience may not be suitable for this project.

The freelancer should be capable of taking the project from architecture/design → GCP setup → GKE configuration → virtualization → load balancing → storage → security → testing → final deployment and handover.

How to Apply

Please send your resume and a cover letter outlining your relevant experience to [email protected] , [email protected]

📌 Freelancer DevOps Engineer with GKE (Gurugram)
🏢 AAIZEL INTERNATIONAL TECHNOLOGIES
📍 Gurugram