
Practice 50 Go Lang Deployment and DevOps Coding Questions
Q1. Write a Go program that demonstrates how to package a Go application for deployment.
Input:
Use go build to compile a simple "Hello, World!" program.
Expected Output:
Executable file: hello-world (binary file)
Q2. Write a Go program that uses environment variables for configuration.
Input:
Set an environment variable DB_HOST=localhost and retrieve it in your Go program.
Expected Output:
DB_HOST: localhost
Q3. Write a Go program that logs application errors to a file.
Input:
Log an error message to a file "app.log" with the content "Database connection failed."
Expected Output:
Content written to "app.log": Database connection failed.
Q4. Write a Go program that uses os/exec to execute a shell command during deployment.
Input:
Execute the shell command echo Hello World using os/exec
Expected Output:
Hello World
Q5. Write a Go program that sets up a simple HTTP server for deployment.
Input:
Start an HTTP server on port 8080 that responds with "Hello, World!"
Expected Output:
HTTP Server started on http://localhost:8080
Q6. Write a Go program that uses logrus for structured logging in production.
Input:
Log a message with structured fields using logrus (e.g., "error", "message").
Expected Output:
{"level":"error","msg":"Message logging","time":"2025-01-14T12:00:00Z"}
Q7. Write a Go program that generates a Dockerfile for containerizing a Go application.
Input:
Generate a Dockerfile to build a Go application into a Docker container.
Expected Output:
Dockerfile:
FROM golang:alpine
WORKDIR /app
COPY . .
RUN go build -o myapp .
CMD ["./myapp"]
Q8. Write a Go program that uploads application logs to a cloud storage service.
Input:
Upload a file "app.log" to an S3 bucket using Go's AWS SDK.
Expected Output:
File "app.log" uploaded to S3 successfully.
Q9. Write a Go program that uses os and os/exec to deploy a web app with CI/CD pipelines.
Input:
Use os/exec to automate git pull and deployment steps on a remote server.
Expected Output:
Code pulled from repository, deployment started.
Q10. Write a Go program that interacts with Kubernetes using the Go client.
Input:
Use Kubernetes Go client to list the pods in a cluster.
Expected Output:
Pods: ["pod-1", "pod-2", "pod-3"]
Q11. Write a Go program that monitors CPU usage in real-time during deployment.
Input:
Use Go to monitor CPU usage during the deployment of an application.
Expected Output:
CPU Usage: 25%
Q12. Write a Go program that configures a continuous integration tool to automatically run tests after a code push.
Input:
Set up a CI/CD pipeline in GitHub Actions or Jenkins to run tests on push events.
Expected Output:
Tests completed successfully after code push.
Q13. Write a Go program that packages your Go app into a .tar.gz file for deployment.
Input:
Create a .tar.gz archive containing your Go app and dependencies.
Expected Output:
File app.tar.gz created successfully.
Q14. Write a Go program that checks the health of your deployment using HTTP requests.
Input:
Send a GET request to http://localhost:8080/health and check for a 200 OK status.
Expected Output:
Health check: OK
Q15. Write a Go program that handles the graceful shutdown of a web server during deployment.
Input:
Use http.Server with a context to shutdown gracefully when the deployment ends.
Expected Output:
Server shutdown completed successfully.
Q16. Write a Go program that sends a deployment status update to Slack using a webhook.
Input:
Send a message "Deployment successful" to Slack via a webhook.
Expected Output:
Message sent to Slack: Deployment successful
Q17. Write a Go program that integrates with Docker Compose for multi-container deployment.
Input:
Set up Docker Compose to run both a Go app and a database container.
Expected Output:
Containers started successfully: app, db
Q18. Write a Go program that manages multiple environment configurations for deployment.
Input:
Load environment-specific configurations using godotenv package.
Expected Output:
Configuration loaded for Production.
Q19. Write a Go program that builds and pushes a Go application Docker image to a registry.
Input:
Build and push Docker image myapp:latest to DockerHub.
Expected Output:
Image pushed successfully to DockerHub.
Q20. Write a Go program that configures monitoring and alerting for your deployed application using Prometheus.
Input:
Set up Prometheus to collect metrics and alert if CPU usage exceeds 80%.
Expected Output:
Alert triggered: CPU usage > 80%
Q21. Write a Go program that uses Git to deploy code to a remote server automatically.
Input:
Use Go to clone a Git repository and deploy the app on a remote server.
Expected Output:
Code deployed from GitHub repository to server.
Q22. Write a Go program that sends an email notification when deployment is successful.
Input:
Send an email to "admin@example.com" when deployment completes.
Expected Output:
Email sent to admin@example.com: Deployment successful
Q23. Write a Go program that configures a reverse proxy using http.ServeMux for deployment.
Input:
Set up a reverse proxy in Go to forward requests from /api to a backend service.
Expected Output:
Reverse proxy set up to forward /api requests.
Q24. Write a Go program that automatically installs dependencies before deployment using go mod.
Input:
Run go mod tidy to install dependencies before starting the application.
Expected Output:
Dependencies installed successfully.
Q25. Write a Go program that deploys a Go application to a cloud provider like AWS or GCP.
Input:
Deploy the application to AWS EC2 instance using Go SDK.
Expected Output:
Application deployed to AWS EC2 instance.
Q26. Write a Go program that uses net/http to serve a simple API in a production environment.
Input:
Set up a REST API that responds to GET requests with a JSON payload.
Expected Output:
Response: {"status": "success"}
Q27. Write a Go program that sets up a basic SSL configuration for an HTTPS server.
Input:
Configure your Go server to serve HTTPS using an SSL certificate.
Expected Output:
HTTPS Server running on https://localhost:443
Q28. Write a Go program that runs automated tests as part of your deployment pipeline.
Input:
Run go test on a Go project before deploying to production.
Expected Output:
Tests passed successfully.
Q29. Write a Go program that uses os/exec to restart a service after deployment.
Input:
Restart the service myapp using systemctl command after deployment.
Expected Output:
Service myapp restarted successfully.
Q30. Write a Go program that automatically scales a deployed service based on load using Kubernetes.
Input:
Use Go Kubernetes client to scale pods based on CPU usage.
Expected Output:
Pods scaled to 3 replicas.
Q31. Write a Go program that integrates with AWS Lambda for serverless deployment.
Input:
Deploy a simple Go function as AWS Lambda.
Expected Output:
Lambda function deployed successfully.
Q32. Write a Go program that manages different versions of the Go application using Git tags.
Input:
Tag the current commit with v1.0.0 and push to the remote repository.
Expected Output:
Git tag v1.0.0 created and pushed.
Q33. Write a Go program that demonstrates zero-downtime deployment using Blue-Green strategy.
Input:
Deploy a new version of the app without downtime using a Blue-Green deployment.
Expected Output:
Blue-Green deployment completed.
Q34. Write a Go program that integrates with a cloud logging system (e.g., AWS CloudWatch) for log aggregation.
Input:
Send logs to AWS CloudWatch after application startup.
Expected Output:
Log sent to AWS CloudWatch successfully.
Q35. Write a Go program that checks disk space usage on the server during deployment.
Input:
Check disk space and warn if it's above 80% usage.
Expected Output:
Disk space usage: 85%
Warning: Disk space usage is high.
Q36. Write a Go program that verifies the integrity of files before deployment using hash checking.
Input:
Verify file integrity by comparing SHA256 hash before deployment.
Expected Output:
File integrity verified: hashes match.
Q37. Write a Go program that demonstrates rolling deployment by updating one instance at a time.
Input:
Deploy new code to one instance, then proceed to others.
Expected Output:
Rolling update completed.
Q38. Write a Go program that configures and deploys an application with Helm charts.
Input:
Deploy a Go app using Helm on a Kubernetes cluster.
Expected Output:
Application deployed using Helm chart.
Q39. Write a Go program that demonstrates deployment monitoring with Grafana.
Input:
Set up Grafana dashboards to monitor the app's deployment.
Expected Output:
Grafana dashboard configured successfully.
Q40. Write a Go program that handles versioning of deployed applications using Docker tags.
Input:
Tag your Docker image with v1.0.0 before pushing it to Docker Hub.
Expected Output:
Docker image tagged: v1.0.0
Q41. Write a Go program that updates the application configuration in production using Consul.
Input:
Update app settings using Consul and propagate changes without restarting the app.
Expected Output:
App configuration updated successfully.
Q42. Write a Go program that monitors deployment health with alerting via Slack.
Input:
Send an alert to Slack if deployment fails.
Expected Output:
Alert sent to Slack: Deployment failed.
Q43. Write a Go program that scales a Go web app based on incoming traffic using AWS Auto Scaling.
Input:
Set up auto scaling for your web app based on traffic volume.
Expected Output:
Auto scaling triggered: 5 instances running.
Q44. Write a Go program that demonstrates setting up CI/CD pipelines with GitLab CI.
Input:
Configure .gitlab-ci.yml for automatic testing and deployment.
Expected Output:
Pipeline executed successfully.
Q45. Write a Go program that demonstrates serverless deployment with Google Cloud Functions.
Input:
Deploy a Go function to Google Cloud Functions.
Expected Output:
Function deployed to Google Cloud Functions.
Q46. Write a Go program that demonstrates log rotation for deployed applications.
Input:
Rotate logs daily for the application using logrotate config.
Expected Output:
Logs rotated successfully.
Q47. Write a Go program that checks for orphaned containers after a deployment using Docker.
Input:
List and remove orphaned Docker containers after deployment.
Expected Output:
Orphaned container removed: mycontainer
Q48. Write a Go program that configures a monitoring agent for a deployed app using Datadog.
Input:
Install and configure Datadog monitoring agent for your Go app.
Expected Output:
Datadog agent configured and sending metrics.
Q49. Write a Go program that handles load balancing during deployment using NGINX.
Input:
Set up NGINX as a load balancer for multiple instances of your Go app.
Expected Output:
Load balancing set up successfully.
Q50. Write a Go program that demonstrates version management using Git and GitLab.
Input:
Create a Git tag v2.0 for a new release and push it to GitLab.
Expected Output:
Git tag v2.0 created and pushed to GitLab.