IT Project Management

By Dr. Nandita Bhanja Chaudhuri

Unit 5
Projects- IT Services Project Management processes- ITIL.
Containerization- deployment of applications using containers. Docker
Engine, Virtual Machines vs. Containers. Challenges with Containers.
Case studies
Service Projects in IT
• Service projects in IT are initiatives undertaken to design, develop,
implement, or enhance IT services. These projects align closely with
IT Service Management (ITSM) frameworks and methodologies,
ensuring they deliver value to the business through well-managed
services.
IT Services Project Management Processes
Project Management for IT Services combines traditional project
management practices (like PMBOK, PRINCE2) with IT Service
Management frameworks, especially ITIL (Information Technology
Infrastructure Library).
• Common Phases in IT Service Projects
[Link] & Requirement Gathering
1. Business case development
2. Defining project scope and service requirements
3. Identifying stakeholders
[Link]
• Service design plans
• Resource allocation
• Risk management plans
• Integration with service transition processes (Change Management)
[Link]
• Building infrastructure/software
• Testing (Functional, Non-functional, UAT)
• Service introduction and deployment
• Knowledge transfer and documentation creation
[Link] & Controlling
• Tracking project progress
• Managing changes (linked to Change Management process)
• Ensuring alignment with ITIL processes (like Incident/Problem
Management)
[Link]
• Service handover to Operations
• Post Implementation Review (PIR)
• Lessons learned
Role of ITIL in Service Projects
ITIL focuses on the lifecycle of IT services, ensuring they are delivered
efficiently and aligned with business needs. ITIL processes are
integrated into IT service projects to ensure:
• Services meet agreed Service Level Agreements (SLAs)
• There’s a clear process for transitioning new/changed services into
production
• Continual improvement is part of the service lifecycle
ITIL Lifecycle Phases Relevant to Projects
Key ITIL Processes Relevant to Projects
Example Scenario
• Service Strategy: Justify investment, define service goals
• Service Design: Design platform architecture, workflows, and
integrations
• Service Transition: Build platform, test it, manage changes, and
deploy it
• Service Operation: Hand over to Service Desk team for ongoing
support
• Continual Improvement: Gather feedback, analyze incidents, and
optimize the platform
• What is ITIL?
• ITIL (Information Technology Infrastructure Library) is a globally
recognized framework for IT Service Management (ITSM). It provides
best practices for delivering IT services that align with business
needs. ITIL focuses on continually improving IT services throughout
their lifecycle.
Key Components
• ITIL breaks down into 5 core stages, often called the ITIL Service
Lifecycle:
[Link] Strategy – Aligning IT services with business goals.
[Link] Design – Designing services and processes.
[Link] Transition – Moving services from development to
production.
[Link] Operation – Managing and supporting live services.
[Link] Service Improvement (CSI) – Monitoring and enhancing
services over time.
ITIL Processes (A Few Examples)
• Incident Management – Handling service disruptions.
• Change Management – Managing changes to services.
• Problem Management – Finding root causes and preventing
incidents.
• Service Level Management – Ensuring service levels meet business
expectations.
Benefits of ITIL
• Improved service quality.
• Better alignment between IT and business.
• Clearer roles and responsibilities.
• Structured processes for handling incidents, problems, and changes.
• Enhanced customer satisfaction.

ITIL Versions
• ITIL v3 – Focused on processes and the service lifecycle.
• ITIL 4 – Focuses more on value creation, agility, and integrates better
with modern practices like DevOps and Agile.
Containerization
• Containerization is a lightweight form of virtualization where
applications and all their dependencies (libraries, configuration files,
etc.) are packaged into a single unit, called a container. These
containers can then run consistently across different environments —
from a developer’s laptop to a production server.
Key Benefits
• Portability – "Works on my machine" becomes less of a problem
because containers work the same everywhere.
• Isolation – Each container runs independently with its own
dependencies.
• Resource Efficiency – Containers are lightweight, sharing the host OS
kernel (unlike traditional VMs).
• Scalability – Ideal for microservices, containers can be easily spun up
or down.
How It Works (Compared to Virtual Machines)
Popular Container Platforms
• Docker – The most popular tool for creating and running containers.
• Podman – Similar to Docker but daemonless (no root privileges
required).
• LXC – Older, more system-level container technology.

Orchestration (Managing Lots of Containers)

• If you're deploying lots of containers (like in a microservices
architecture), you need an orchestrator to manage them:
• Kubernetes – Most popular container orchestration platform.
• Docker Swarm – Simpler orchestration directly from Docker.
• OpenShift – Enterprise Kubernetes from Red Hat.
Common Use Cases
• Microservices – Each microservice can run in its own container.
• CI/CD Pipelines – Containers are often part of build/test/deploy
pipelines.
• Hybrid Cloud – Run the same containers on-prem or in cloud.
Why It Matters
• Containerization is a key enabler for:
• Cloud-native apps
• DevOps
• CI/CD
• Scalability and Resilience
Deployment of applications using containers
Step 1: Containerize the Application
• You package the application and its dependencies into a container
image.
• Tools:
• Docker – Most common container tool.
• Podman – A rootless alternative to Docker.
• Buildah – Another image builder, used in CI/CD pipelines.
Step 2: Store Images in a Container Registry
• You push the container image to a registry so it can be pulled by
other environments (like test, staging, production).
• Popular Container Registries:
• Docker Hub (public)
• AWS ECR (Amazon Elastic Container Registry)
• Azure Container Registry
• Google Artifact Registry
• Harbor (on-prem)
Step 3: Define Deployment Configurations
This includes:
• Number of replicas (instances)
• Environment variables
• Ports to expose
• Storage requirements (volumes)
• Typical Tools:
• Docker Compose (simple setups)
• Kubernetes YAML (for clusters)
• Step 4: Deploy to Environment (Test, Staging, Production)
• Depending on the environment, you deploy using:
• Local Development
• Kubernetes (Production-like)

Step 5: Expose the Application

• For external access, you expose the container via:
• Kubernetes Service (LoadBalancer, ClusterIP, NodePort)
• Ingress Controller (for HTTP/HTTPS traffic)
• Service Mesh (in complex environments)
Step 6: Monitor and Manage
• Once deployed, you need to:
• Monitor application health
• Scale as needed
• Rollout updates (new images)
• Tools:
• Prometheus & Grafana – Monitoring
• Kubernetes Horizontal Pod Autoscaler (HPA) – Auto-scaling
• ArgoCD / Flux – GitOps (automate deployment changes)
Step 7: Automate with CI/CD Pipelines
• Most organizations automate container builds, tests, and
deployments using tools like:
• Jenkins
• GitHub Actions
• GitLab CI
• Azure DevOps Pipelines
• Example Workflow
[Link] pushed to GitHub
[Link] Action builds Container image
[Link] image to container registry
[Link] to Kubernetes cluster
Docker Engine
• Docker Engine is a containerization platform that allows developers to
build, package, and run applications in lightweight, portable
containers. It provides an efficient way to manage application
dependencies, ensuring consistency across different environments.
Key Components:
• Docker Daemon – A background service that manages containers,
images, and networks.
• Docker CLI (Command-Line Interface) – A tool for interacting with the
Docker Daemon using commands like docker run, docker build, etc.
• Docker Images – Read-only templates that contain application code
and dependencies.
• Docker Containers – Running instances of Docker images that
encapsulate applications.
• Docker Registries – Repositories like Docker Hub or private registries
to store and distribute images.
Features & Benefits:
• Lightweight & Fast – Containers share the host OS kernel, making
them more efficient than VMs.
• Portability – Runs on various environments (local, cloud, or on-
premises).
• Scalability – Supports orchestration tools like Docker Swarm &
Kubernetes.
• Automation & CI/CD – Enables automated deployments and
integration with DevOps pipelines.
Components of Docker Engine
a. Docker Daemon (dockerd)
• A background process that manages Docker objects like images, containers,
networks, and volumes.
• Listens for API requests from the Docker CLI or Docker API.
• Handles tasks like container execution, image management, and network
configuration.
b. Docker CLI (docker)
• A command-line tool that allows users to interact with the Docker Daemon.
• Common commands:
• docker run – Start a new container.
• docker build – Create a Docker image.
• docker ps – List running containers.
• docker stop – Stop a running container.
c. REST (Representational State Transfer) API
• Allows programmatic interaction with the Docker Engine.
• Used by third-party tools and orchestration platforms.
d. Container Runtime
• Manages the actual execution of containers.
• By default, Docker uses runc, a lightweight container runtime.
Docker Engine Editions
• Docker Engine - Community Edition (CE): Free and open-source,
suitable for developers and small projects.
• Docker Engine - Enterprise Edition (EE): Includes advanced security,
management, and support for enterprise applications.
How Docker Engine Works
• Pull an Image: Users can download (pull) images from Docker Hub or
a private registry.
• Create a Container: A container instance is launched from an image.
• Networking & Storage: Containers can be connected via Docker
networks and persist data using volumes.
• Container Lifecycle Management: Containers can be started,
stopped, paused, and removed as needed.
Virtual machines vs containers
1. Architecture
• Virtual Machines (VMs):
• Each VM runs a full operating system (OS) on top of a hypervisor (allows
multiple VMs to run in a single physical machine).
• VMs include a full guest OS, virtualized hardware, and applications.
• Common hypervisors: VMware, Hyper-V, KVM, VirtualBox.
• Containers:
• Containers share the host OS kernel but run isolated environments.
• They are lightweight and contain only the application and its dependencies.
• Common container platforms: Docker, Kubernetes, Podman.
2. Performance
• VMs:
• Heavier since each VM requires its own OS.
• Slower startup times (seconds to minutes).
• More resource-intensive due to OS overhead.
• Containers:
• Lighter as they share the host OS kernel.
• Faster startup times (milliseconds to seconds).
• More efficient use of resources.
3. Isolation & Security
• VMs:
• Stronger isolation since each VM has a separate OS.
• More secure but requires more resources.
• Containers:
• Weaker isolation as they share the OS kernel.
• More vulnerable to kernel exploits.
4. Portability
• VMs:
• Less portable due to OS dependencies and larger size.
• Requires hypervisor compatibility.
• Containers:
• Highly portable across different environments (cloud, on-premises, dev
machines).
• Can run on any system with a compatible container runtime.
5. Use Cases
• VMs:
• Running multiple OS environments on one machine.
• Traditional enterprise applications.
• High-security applications requiring strong isolation.
• Containers:
• Microservices and cloud-native applications.
• Fast deployment and scaling.
• CI/CD pipelines.
Challenges with Containers
Containers offer many advantages, but they also come with challenges. Here
are some key issues organizations face when adopting containerized
environments:
1. Security Concerns
• Kernel Sharing: Containers share the host OS kernel, increasing the risk of
exploits affecting multiple containers.
• Vulnerable Images: If container images are not properly scanned and
maintained, they may contain vulnerabilities.
• Privilege Escalation: Running containers as root can lead to security risks.
• Isolation Issues: Containers don’t provide the same level of isolation as
VMs, making multi-tenant environments riskier.
2. Networking Complexity
• Service Discovery: Managing communication between containers
across hosts requires additional tools like service meshes.
• Networking Overhead: Setting up overlay networks (e.g., in
Kubernetes) adds complexity and can impact performance.
• Port Management: Since containers share the host’s networking
stack, handling ports properly is crucial.
3. Storage Persistence
• Ephemeral Nature: Containers are designed to be stateless, but many
applications need persistent storage.
• Data Management: Storing and managing data across container restarts
and migrations requires external solutions (e.g., volumes, object storage).
• Performance Overhead: Using shared or networked storage may introduce
performance bottlenecks.
4. Orchestration Complexity
• Learning Curve: Kubernetes, the most popular container orchestration
tool, has a steep learning curve.
• Resource Management: Optimizing CPU, memory, and scaling policies
requires constant tuning.
• Monitoring & Logging: Observability tools (Prometheus, Grafana,
ELK(Elasticsearch Logstash Kibana) stack) are needed to track performance
and troubleshoot issues.
5. Compatibility Issues
• Host OS Dependency: Containers depend on the host OS kernel, limiting
portability compared to VMs.
• Image Compatibility: Different base images may lead to dependency
conflicts or runtime issues.
• Vendor Lock-in: Some container platforms (like AWS Fargate or Google
Cloud Run) create dependency on cloud providers.
6. Compliance & Governance
• Regulatory Challenges: Ensuring compliance with industry standards (e.g.,
GDPR- General Data Protection Regulation) is harder due to dynamic
containerized environments.
• Access Control: Managing RBAC (Role-Based Access Control) across clusters
and namespaces is complex.
• Audit & Logging: Containers spin up and down frequently, making tracking
user actions and system logs challenging.
7. Performance Overhead
• Resource Contention: Misconfigured resource limits can lead to over- or
under-utilization.
• Startup Overhead: Although faster than VMs, initializing many containers
at once can create performance spikes.
• Container Runtime Differences: Different runtimes (Docker, containerd,
CRI-O) may behave differently in various environments.
8. Image Management & Supply Chain Security
• Image Bloat: A container image becomes unnecessarily large because it
includes extra or unused files, tools, or dependencies.
• Dependency Hell: Managing package dependencies across different images
can lead to inconsistencies.
• Supply Chain Attacks: Malicious images or compromised registries (e.g.,
Docker Hub) pose security threats.
9. Troubleshooting & Debugging
• Short Lifespan: Containers can start and stop quickly, making it difficult to
capture logs and diagnose issues.
• Distributed Systems Complexity: Debugging microservices architectures
spread across multiple containers is harder than monolithic applications.
• Tooling Gaps: Traditional debugging tools may not work well in
containerized environments.
10. Cost Management
• Underutilized Resources: If autoscaling is not configured properly,
resources may be wasted.
• Networking Costs: Cloud-based container networking (e.g., Kubernetes
ingress/egress traffic) can become expensive.
• Storage Costs: Persistent storage solutions add costs, especially in multi-
cloud setups.
How to Mitigate These Challenges
• Security Best Practices: Use image scanning, least-privilege access,
and container security tools (e.g., Falco, Aqua Security).
• Networking Solutions: Implement service meshes (Istio, Linkerd) and
monitoring tools.
• Storage Strategies: Use managed storage solutions (e.g., AWS EFS,
Google Persistent Disks).
• Orchestration Best Practices: Optimize Kubernetes configurations
and use automation tools.
• Observability Tools: Implement logging and monitoring with
Prometheus, Grafana.