DEVOPS INTERNSHIP

DevOps Practical Task Portal

Beginner to Intermediate Practical Learning & Implementation

🚀 Introduction to DevOps Practical Training

Welcome to the practical task portal for the DevOps Internship. This portal is designed to help you understand how modern software development and IT operations work together.

Instead of learning DevOps only through theory, you will perform practical activities using commonly used tools such as Linux, Git, GitHub, Docker and GitHub Actions.

The tasks have been designed at a beginner-to-intermediate level. You do not need advanced DevOps knowledge to complete them. Follow each task step-by-step and maintain screenshots, files, commands and notes as evidence of your practical work.

🎯 Training Objective

The objective of this practical internship is to give you hands-on exposure to the basic DevOps workflow — from managing source code to containerizing an application and creating a simple automated deployment pipeline.

By completing these tasks, you will build a small practical DevOps portfolio that demonstrates your understanding of development, version control, containers, automation and operational practices.

📚 Learning Outcomes

After completing the practical tasks, you should be able to:

Understand the basic DevOps lifecycle.
Work with Linux command-line tools.
Create and manage Git repositories.
Use GitHub for source-code management.
Understand branches, commits and pull requests.
Create a basic Dockerfile.
Build and run a Docker container.
Understand basic CI/CD concepts.
Create a simple GitHub Actions workflow.
Read basic build and deployment logs.
Document technical work professionally.

⚠️ Important Instructions

Complete all 5 practical tasks.
Perform the practical work yourself rather than only watching tutorials.
Maintain screenshots of important steps, commands and successful results.
Keep your project files organized in a single DevOps internship folder.
You may use Windows, Linux or WSL depending on your system.
If you do not have access to a cloud account, complete the practical tasks locally wherever possible.
Do not upload passwords, API keys, private SSH keys, access tokens or other confidential credentials.
Your submission should contain your practical work, screenshots and a short explanation of what you learned.
Complete the tasks within the deadline communicated by the internship/admin team.

✅ TASK 1: Linux & DevOps Environment Setup

🎯 Objective

Learn the basic Linux commands used by DevOps engineers and prepare a simple working environment for DevOps activities.

🛠 Practical Work

Perform the following activities:

Open a Linux terminal or WSL terminal.
Create a folder named devops-internship.
Create a project folder inside it.
Create at least three text files.
Rename one file.
Copy one file to another folder.
Move one file to another location.
Delete a test file.
Display the current working directory.
List files using different Linux commands.
Check basic file permissions.
Use a package manager to check installed packages.

💻 Suggested Commands to Practice

📸 Submission Evidence

Screenshot of your DevOps folder.
Screenshot of Linux commands being executed.
Short explanation of 5 Linux commands.

✅ TASK 2: Git & GitHub Repository Management

🎯 Objective

Understand how DevOps teams use Git and GitHub to manage, track and collaborate on source code.

🛠 Practical Work

Install Git if it is not already installed.
Create a GitHub account if required.
Create a new GitHub repository.
Clone the repository to your computer.
Create a simple HTML file.
Add the file to the Git repository.
Create your first commit.
Push the code to GitHub.
Create a new branch.
Make a small change in the branch.
Commit and push the change.
Create a Pull Request on GitHub.

💻 Commands to Practice

                git init

                git clone

                git status

                git add .

                git commit -m "Initial commit"

                git branch

                git checkout

                git push

                git pull

📸 Submission Evidence

GitHub repository screenshot.
Commit history screenshot.
Branch screenshot.
Pull Request screenshot.
Repository link.

✅ TASK 3: Dockerize a Simple Application

🎯 Objective

Learn the fundamentals of Docker by creating a small application, writing a Dockerfile and running the application inside a container.

🛠 Practical Work

Install Docker Desktop or Docker Engine.
Create a simple HTML application.
Create a file named Dockerfile.
Define the required base image.
Copy your application into the container.
Build a Docker image.
Check the available Docker images.
Run the Docker container.
Access your application through localhost.
Stop the container.
Start the container again.

🔎 Concepts to Understand

Docker Image
Docker Container
Dockerfile
Port Mapping
Container Lifecycle

💻 Commands to Practice

                docker --version

                docker build

                docker images

                docker run

                docker ps

                docker stop

                docker start

📸 Submission Evidence

Dockerfile screenshot.
Docker image screenshot.
Running container screenshot.
Browser screenshot showing the application.
Short explanation of Image vs Container.

✅ TASK 4: Create a Basic CI/CD Pipeline with GitHub Actions

🎯 Objective

Understand how automation can be used to automatically test or process code whenever changes are pushed to a GitHub repository.

🛠 Practical Work

Open your GitHub repository from Task 2.
Create the folder: .github/workflows
Create a workflow YAML file.
Configure the workflow to run when code is pushed.
Add a simple job.
Add steps to check out the repository.
Add a step that displays a successful message.
Commit and push the workflow file.
Open the Actions section of GitHub.
Check whether the workflow runs successfully.
Make another small change and push it to GitHub.
Verify that the workflow runs again automatically.

🔎 Concepts to Understand

Continuous Integration
Continuous Deployment
Workflow
Trigger
Job
Step
Runner
Workflow Logs

📸 Submission Evidence

Workflow YAML file screenshot.
GitHub Actions workflow screenshot.
Successful workflow run screenshot.
Workflow log screenshot.
Short explanation of CI/CD.

✅ TASK 5: DevOps Monitoring & Deployment Documentation

🎯 Objective

Learn how DevOps engineers check application status, review logs and document deployment information for troubleshooting and future maintenance.

🛠 Practical Work

Run your Docker application from Task 3.
Check the currently running containers.
Check the application logs.
Stop the container and observe the status.
Start the container again.
Check whether the application is accessible.
Identify one possible application failure scenario.
Explain how you would investigate that problem.
Create a simple deployment documentation file.

📄 Create a DevOps Deployment Report

Your report should contain:

Project name
Application description
Tools used
GitHub repository information
Docker image information
Container information
How the application was started
How logs were checked
One problem/error scenario
How the problem could be investigated
What you learned from the internship tasks

💻 Commands to Practice

                docker ps

                docker ps -a

                docker logs

                docker start

                docker stop

📸 Submission Evidence

Container status screenshot.
Application logs screenshot.
Application running screenshot.
Deployment documentation/report.
Short troubleshooting explanation.

📤 Final Task Submission

After completing all 5 tasks, organize your practical work, screenshots, GitHub repository links and documentation.

Make sure your submission is complete before submitting the Google Form.

📤 SUBMIT COMPLETED TASKS

✅ Attendance

Please mark your attendance using the official attendance form.

MARK ATTENDANCE

DevOps Internship Practical Task Portal
Learn • Practice • Implement • Document

Please do not submit passwords, API keys, SSH private keys, access tokens or other confidential credentials.