Notes on DevOps

      UserData: 
        Fn::Base64: |
          #!/bin/bash -xe
          echo "Update..."
          yum update -y
          echo "Installing tmux..."
          yum -y install tmux
          echo "Installing development libs..."
          yum -y install @development zlib-devel bzip2 bzip2-devel readline-devel sqlite sqlite-devel openssl-devel xz xz-devel libffi-devel findutils
          echo "Installing git..."
          yum -y install git
          echo "Installing jq..."
          yum -y install jq
          echo "Installing docker..."
          amazon-linux-extras install -y docker
          echo "Add ec2-user to docker..."
          usermod -a -G docker ec2-user
          
          # # curl -LS --connect-timeout 15 \
          # #   --retry 5 \
          # #   --retry-delay 5 \
          # #   --retry-max-time 60 \
          # #   "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
          # # unzip -u awscliv2.zip
          # # ./aws/install
          # # rm awscliv2.zip

          wait
          echo "Installing AWS SAM..."
          curl -LS --connect-timeout 15 \
            --retry 5 \
            --retry-delay 5 \
            --retry-max-time 60 \
            "https://github.com/aws/aws-sam-cli/releases/latest/download/aws-sam-cli-linux-x86_64.zip" -o "aws-sam-cli-linux-x86_64.zip" 
          unzip aws-sam-cli-linux-x86_64.zip -d sam-installation
          ./sam-installation/install
          rm aws-sam-cli-linux-x86_64.zip
          
          wait
          sudo -u ec2-user -i <<'EOF'

          echo '--- Install docker-compose for ec2-user ---' 
          echo 'export DOCKER_CONFIG=${DOCKER_CONFIG:-$HOME/.docker}' >>  ~/.bashrc
          echo 'export PATH="$DOCKER_CONFIG/cli-plugins:$PATH"' >> ~/.bashrc
          source ~/.bashrc
          
          mkdir -p $DOCKER_CONFIG/cli-plugins
          curl -LS --connect-timeout 15 \
            --retry 5 \
            --retry-delay 0 \
            --retry-max-time 60 \
            https://github.com/docker/compose/releases/download/v2.11.0/docker-compose-linux-x86_64 -o $DOCKER_CONFIG/cli-plugins/docker-compose
          chmod +x $DOCKER_CONFIG/cli-plugins/docker-compose
          

          echo '--- Install pyenv for ec2-user ---'
          source ~/.bashrc

          RETRIES=3; DELAY=10; COUNT=1; while [ $COUNT -lt $RETRIES ]; do git clone https://github.com/pyenv/pyenv.git $HOME/.pyenv; if [ $? -eq 0 ]; then RETRIES=0;  break; fi; let COUNT=$COUNT+1; sleep $DELAY; done
          echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bashrc
          echo 'command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bashrc
          echo 'eval "$(pyenv init -)"' >> ~/.bashrc
          source ~/.bashrc

          RETRIES=3; DELAY=10; COUNT=1; while [ $COUNT -lt $RETRIES ]; do git clone https://github.com/pyenv/pyenv-virtualenv.git $(pyenv root)/plugins/pyenv-virtualenv; if [ $? -eq 0 ]; then RETRIES=0;  break; fi; let COUNT=$COUNT+1; sleep $DELAY; done
          echo '--- Install git-remote for ec2-user ---'
          pip3 install git-remote-codecommit

          echo "Insalling python environment for AWS Lambda development..."
          echo 'export TMPDIR="$HOME/tmp"' >>  ~/.bashrc
          source ~/.bashrc
          RETRIES=3; DELAY=10; COUNT=1; while [ $COUNT -lt $RETRIES ]; do pyenv install 3.9.14 ; if [ $? -eq 0 ]; then RETRIES=0;  break; fi; let COUNT=$COUNT+1; sleep $DELAY; done
          pyenv virtualenv 3.9.14 p39

          echo '--- end ---'          
          EOF

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Action": [
                "cloudformation:*",
                "lambda:*",
                "sns:*",
                "events:*",
                "logs:*",
                "ec2:*",
                "s3:*",
                "dynamodb:*",
                "kms:*",
                "iam:*",
                "states:*",
                "sts:*",
                "sqs:*",
                "elasticfilesystem:*",
                "config:*",
                "cloudwatch:*",
                "apigateway:*",
                "backup:*",
                "firehose:*",
                "backup-storage:*",
                "ssm:*"
            ],
            "Resource": "*",
            "Effect": "Allow"
        }
    ]
}

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "CloudFormationTemplate",
            "Effect": "Allow",
            "Action": [
                "cloudformation:CreateChangeSet"
            ],
            "Resource": [
                "arn:aws:cloudformation:*:aws:transform/Serverless-2016-10-31"
            ]
        },
        {
            "Sid": "CloudFormationStack",
            "Effect": "Allow",
            "Action": [
                "cloudformation:CreateChangeSet",
                "cloudformation:CreateStack",
                "cloudformation:DeleteStack",
                "cloudformation:DescribeChangeSet",
                "cloudformation:DescribeStackEvents",
                "cloudformation:DescribeStacks",
                "cloudformation:ExecuteChangeSet",
                "cloudformation:GetTemplateSummary",
                "cloudformation:ListStackResources",
                "cloudformation:UpdateStack"
            ],
            "Resource": [
                "arn:aws:cloudformation:*:<account id>:stack/*"
            ]
        },
        {
            "Sid": "S3",
            "Effect": "Allow",
            "Action": [
                "s3:CreateBucket",
                "s3:GetObject",
                "s3:PutObject"
            ],
            "Resource": [
                "arn:aws:s3:::*/*"
            ]
        },
        {
            "Sid": "ECRRepository",
            "Effect": "Allow",
            "Action": [
                "ecr:BatchCheckLayerAvailability",
                "ecr:BatchGetImage",
                "ecr:CompleteLayerUpload",
                "ecr:CreateRepository",
                "ecr:DeleteRepository",
                "ecr:DescribeImages",
                "ecr:DescribeRepositories",
                "ecr:GetDownloadUrlForLayer",
                "ecr:GetRepositoryPolicy",
                "ecr:InitiateLayerUpload",
                "ecr:ListImages",
                "ecr:PutImage",
                "ecr:SetRepositoryPolicy",
                "ecr:UploadLayerPart"
            ],
            "Resource": [
                "arn:aws:ecr:*:<account id>:repository/*"
            ]
        },
        {
            "Sid": "ECRAuthToken",
            "Effect": "Allow",
            "Action": [
                "ecr:GetAuthorizationToken"
            ],
            "Resource": [
                "*"
            ]
        },
        {
            "Sid": "Lambda",
            "Effect": "Allow",
            "Action": [
                "lambda:AddPermission",
                "lambda:CreateFunction",
                "lambda:DeleteFunction",
                "lambda:GetFunction",
                "lambda:GetFunctionConfiguration",
                "lambda:ListTags",
                "lambda:RemovePermission",
                "lambda:TagResource",
                "lambda:UntagResource",
                "lambda:UpdateFunctionCode",
                "lambda:UpdateFunctionConfiguration"
            ],
            "Resource": [
                "arn:aws:lambda:*:<account id>:function:*"
            ]
        },
        {
            "Sid": "IAM",
            "Effect": "Allow",
            "Action": [
                "iam:CreateRole",
                "iam:AttachRolePolicy",
                "iam:DeleteRole",
                "iam:DetachRolePolicy",
                "iam:GetRole",
                "iam:TagRole"
            ],
            "Resource": [
                "arn:aws:iam::<account id>:role/*"
            ]
        },
        {
            "Sid": "IAMPassRole",
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "*",
            "Condition": {
                "StringEquals": {
                    "iam:PassedToService": "lambda.amazonaws.com"
                }
            }
        },
        {
            "Sid": "APIGateway",
            "Effect": "Allow",
            "Action": [
                "apigateway:DELETE",
                "apigateway:GET",
                "apigateway:PATCH",
                "apigateway:POST",
                "apigateway:PUT"
            ],
            "Resource": [
                "arn:aws:apigateway:*::*"
            ]
        }
    ]
}

AWSTemplateFormatVersion: "2010-09-09"
Description: create IAM role

Resources:
  IamRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Sid: AllowAssumeRole
            Effect: Allow
            Principal:
              Service: "cloudformation.amazonaws.com"
            Action: "sts:AssumeRole"
      ManagedPolicyArns:
        - "arn:aws:iam::aws:policy/AdministratorAccess"
Outputs:
  IamRole:
    Value: !GetAtt IamRole.Arn     

AWSTemplateFormatVersion: "2010-09-09"
Description: This is my first bucket

Resources:
  ojithadeletebucket:
    Type: AWS::S3::Bucket

trigger:
- azure-pipelines

pool:
  vmImage: ubuntu-latest

stages:
- stage: Build
  jobs:
    - job: build_job
      steps:
        - bash: echo 'Build stage job.'
          displayName: 'Run a one-line script'
- stage: Release
  jobs:
    - job: release_job
      steps:
        - bash: echo 'Relase stage job'
          displayName: 'Run a one-line script' 

schedules:
- cron: '0 0 * * *'
  displayName: Daily midnight build
  branches:
    include:
    - main

schedules:
- cron: ...
  ...
  always: true

schedules:
- cron: '30 21 * * Sun-Thu'
  displayName: M-F 3:00 AM (UTC + 5:30) India daily build
  branches:
    include:
    - /features/india/*

...
- cron: '0 8 * * Mon-Fri'
  displayName: M-F 3:00 AM (UTC - 5) NC daily build
  branches:
    include:
    - /features/nc/*

# Docker
# Build a Docker image and save it as a tar file
# https://docs.microsoft.com/azure/devops/pipelines/languages/docker

trigger:
- master

resources:
- repo: self

variables:
  # tag: '$(Build.BuildId)'
  tag: 'latest'
  DOCKER_BUILDKIT: 1
  imageName: 'ojitha/test'
  # Create a simpler output filename without the repository path structure
  imageFileName: 'test-$(tag).tar'

stages:
- stage: Build
  displayName: Build image
  jobs:
  - job: Build
    displayName: Build
    pool:
      name: Ubuntu 
      demands: 
      - agent.name -equals ojitha
    steps:
    - task: Docker@2
      displayName: Build an image
      inputs:
        repository: $(imageName)
        command: build
        dockerfile: '$(Build.SourcesDirectory)/Dockerfile'
        tags: |
          $(tag)
    
    - script: |
        # Create the directory if it doesn't exist
        mkdir -p $(Build.ArtifactStagingDirectory)
        
        # Save the Docker image to a tar file with a simpler name
        docker save $(imageName):$(tag) -o $(Build.ArtifactStagingDirectory)/$(imageFileName)
        
        # Display saved file for verification
        ls -la $(Build.ArtifactStagingDirectory)
      displayName: 'Save Docker image to tar file'
    
    - task: PublishBuildArtifacts@1
      inputs:
        pathToPublish: '$(Build.ArtifactStagingDirectory)'
        artifactName: 'docker-image'
      displayName: 'Publish Docker image tar file as artifact'

trigger:
 - main

pool:
   vmImage: 'ubuntu-latest' 

variables:
  # Docker image configuration
  imageName: 'myapp'
  imageTag: '$(Build.BuildNumber)'
  dockerfilePath: '$(Build.SourcesDirectory)/app/Dockerfile'
  
  # Artifact configuration
  artifactName: 'docker-images'
  dockerTarFileName: '$(imageName)-$(imageTag).tar'

stages:
- stage: BuildDockerImage
  displayName: 'Build Docker Image'
  jobs:
  - job: BuildAndSaveImage
    displayName: 'Build and Save Docker Image'
    steps:
    
    # Checkout source code
    - checkout: self
      displayName: 'Checkout source code'
    
    # Display environment info
    - script: |
        echo "Pipeline: $(Build.DefinitionName)"
        echo "Build Number: $(Build.BuildNumber)"
        echo "Source Branch: $(Build.SourceBranchName)"
        echo "Docker Image: $(imageName):$(imageTag)"
        echo "Dockerfile Path: $(dockerfilePath)"
        docker --version
        df -h
      displayName: 'Display build information'
    
    # Build Docker image
    - script: |
        echo "Building Docker image: $(imageName):$(imageTag)"
        docker build -t $(imageName):$(imageTag) -f $(dockerfilePath) .
        
        # Also tag as latest for convenience
        docker tag $(imageName):$(imageTag) $(imageName):latest
        
        # Display images
        docker images | grep $(imageName)
      displayName: 'Build Docker image'
      workingDirectory: '$(Build.SourcesDirectory)'
    
    # Optional: Test the Docker image
    - script: |
        echo "Testing Docker image..."
        # Run basic container test
        docker run --rm $(imageName):$(imageTag) --version || true
        
        # Check image size
        docker images $(imageName):$(imageTag) --format "table \t\t"
      displayName: 'Test Docker image'
      condition: succeeded()
    
    # Save Docker image to tar file
    - script: |
        echo "Saving Docker image to tar file..."
        mkdir -p $(Agent.TempDirectory)/docker-artifacts
        
        # Save both tagged version and latest
        docker save $(imageName):$(imageTag) $(imageName):latest -o $(Agent.TempDirectory)/docker-artifacts/$(dockerTarFileName)
        
        # Display file info
        ls -lh $(Agent.TempDirectory)/docker-artifacts/
        echo "Docker image saved as: $(dockerTarFileName)"
        echo "File size: $(du -h $(Agent.TempDirectory)/docker-artifacts/$(dockerTarFileName) | cut -f1)"
      displayName: 'Save Docker image to tar file'
    
    # Create metadata file
    - script: |
        echo "Creating metadata file..."
        cat > $(Agent.TempDirectory)/docker-artifacts/image-info.txt << EOF
        Docker Image Information
        ========================
        Image Name: $(imageName)
        Image Tag: $(imageTag)
        Build Number: $(Build.BuildNumber)
        Build Date: $(date)
        Source Branch: $(Build.SourceBranchName)
        Commit ID: $(Build.SourceVersion)
        Pipeline: $(Build.DefinitionName)
        
        Tar File: $(dockerTarFileName)
        
        Import Instructions:
        ===================
        1. Download the artifact from Azure DevOps
        2. Extract the tar file
        3. Load into Docker: docker load -i $(dockerTarFileName)
        4. Verify: docker images | grep $(imageName)
        5. Run: docker run --rm $(imageName):$(imageTag)
        EOF
        
        cat $(Agent.TempDirectory)/docker-artifacts/image-info.txt
      displayName: 'Create metadata file'
    
    # Optional: Create compressed version to save space
    - script: |
        echo "Creating compressed version..."
        cd $(Agent.TempDirectory)/docker-artifacts
        
        # Compress the tar file
        gzip -c $(dockerTarFileName) > $(dockerTarFileName).gz
        
        # Display sizes
        echo "Original size: $(du -h $(dockerTarFileName) | cut -f1)"
        echo "Compressed size: $(du -h $(dockerTarFileName).gz | cut -f1)"
        
        # Keep both versions
        ls -lh
      displayName: 'Create compressed version'
      condition: succeeded()
    
    # Publish Docker image as pipeline artifact
    - task: PublishPipelineArtifact@1
      inputs:
        targetPath: '$(Agent.TempDirectory)/docker-artifacts'
        artifactName: '$(artifactName)'
        publishLocation: 'pipeline'
      displayName: 'Publish Docker image artifact'
    
    # Clean up local Docker images to save space
    - script: |
        echo "Cleaning up local Docker images..."
        docker rmi $(imageName):$(imageTag) $(imageName):latest || true
        docker system prune -f
        df -h
      displayName: 'Clean up Docker images'
      condition: always()

# Optional: Additional stage for multi-architecture builds
- stage: BuildMultiArch
  displayName: 'Build Multi-Architecture Images'
  condition: and(succeeded(), eq(variables['Build.SourceBranchName'], 'main'))
  dependsOn: []
  jobs:
  - job: BuildMultiArchImage
    displayName: 'Build Multi-Arch Docker Image'
    steps:
    - checkout: self
    
    # Set up Docker Buildx for multi-platform builds
    - script: |
        # Enable experimental features
        echo '{"experimental": true}' | sudo tee /etc/docker/daemon.json
        sudo systemctl restart docker
        
        # Set up buildx
        docker buildx create --name multiarch --use
        docker buildx inspect --bootstrap
      displayName: 'Setup Docker Buildx'
    
    # Build multi-architecture images
    - script: |
        echo "Building multi-architecture Docker images..."
        
        # Build for multiple platforms
        docker buildx build \
          --platform linux/amd64,linux/arm64 \
          --tag $(imageName):$(imageTag)-multiarch \
          --file $(dockerfilePath) \
          --output type=docker,dest=$(Agent.TempDirectory)/$(imageName)-$(imageTag)-multiarch.tar \
          .
        
        ls -lh $(Agent.TempDirectory)/$(imageName)-$(imageTag)-multiarch.tar
      displayName: 'Build multi-architecture image'
      workingDirectory: '$(Build.SourcesDirectory)'
    
    # Publish multi-arch artifact
    - task: PublishPipelineArtifact@1
      inputs:
        targetPath: '$(Agent.TempDirectory)/$(imageName)-$(imageTag)-multiarch.tar'
        artifactName: 'docker-images-multiarch'
        publishLocation: 'pipeline'
      displayName: 'Publish multi-arch Docker artifact'

trigger:
  branches:
    include:
      - main
      - master

variables:
  # Global build configuration
  buildNumber: '$(Build.BuildNumber)'
  sourceBranch: '$(Build.SourceBranchName)'

# Build Docker images using the template
stages:
- stage: BuildDockerImages
  displayName: 'Build Docker Images'
  jobs:
  # Build the main application Docker image
  - template: templates/docker-build-template.yml
    parameters:
      imageName: 'myapp'
      imageTag: '$(buildNumber)'
      dockerfilePath: 'app/Dockerfile'
      buildContext: '.'
      artifactName: 'docker-images'
      enableCompression: true
      runTests: true
      testCommand: '--version'  # or 'none' to skip container testing

  # Example: Build additional Docker image (uncomment and modify as needed)
  # - template: templates/docker-build-template.yml
  #   parameters:
  #     imageName: 'myapp-worker'
  #     imageTag: '$(buildNumber)'
  #     dockerfilePath: 'worker/Dockerfile'
  #     buildContext: '.'
  #     artifactName: 'docker-images'
  #     enableCompression: true
  #     runTests: true
  #     testCommand: '--help'

  # Example: Build a different component with custom build args
  # - template: templates/docker-build-template.yml
  #   parameters:
  #     imageName: 'myapp-api'
  #     imageTag: '$(buildNumber)'
  #     dockerfilePath: 'api/Dockerfile'
  #     buildContext: 'api'
  #     buildArgs: 'NODE_ENV=production API_VERSION=v2'
  #     artifactName: 'docker-images'
  #     enableCompression: true
  #     runTests: true
  #     testCommand: 'node --version'

# Optional: Deployment stage that depends on all build stages
- stage: PostBuild
  displayName: 'Post-Build Activities'
  dependsOn: 
    - BuildDockerImages
  condition: succeeded()
  jobs:
  - job: PostBuildTasks
    displayName: 'Post-Build Tasks'
    steps:
    
    # Display build summary
    - script: |
        echo "========================================"
        echo "Build Summary"
        echo "========================================"
        echo "Build completed successfully!"
        echo "Build Number: $(buildNumber)"
        echo "Source Branch: $(sourceBranch)"
        echo "Commit: $(Build.SourceVersion)"
        echo ""
        echo "Images built:"
        echo "- myapp:$(buildNumber)"
        echo ""
        echo "Artifacts available:"
        echo "- docker-images-myapp"
        echo ""
        echo "Next steps:"
        echo "1. Download artifacts from this build"
        echo "2. Load Docker images: docker load -i <tar-file>"
        echo "3. Deploy to target environment"
        echo "========================================"
      displayName: 'Build Summary'
    
    # Optional: Send notification or trigger deployment pipeline
    # Add your post-build tasks here

# Optional: Example of conditional builds based on changed files
# This stage only runs if files in the 'app' directory changed
- stage: BuildOnAppChanges
  displayName: 'Build App (Only on Changes)'
  condition: |
    and(
      succeeded(),
      or(
        contains(variables['Build.SourceVersionMessage'], 'app/'),
        eq(variables['Build.Reason'], 'Manual')
      )
    )
  dependsOn: []
  jobs:
  - template: templates/docker-build-template.yml
    parameters:
      imageName: 'myapp-changed'
      imageTag: '$(buildNumber)-hotfix'
      dockerfilePath: 'Dockerfile'
      buildContext: '.'
      artifactName: 'hotfix-images'
      enableCompression: true
      runTests: true

parameters:
  # Required parameters
  - name: imageName
    type: string
    displayName: 'Docker image name'
    
  - name: dockerfilePath
    type: string
    displayName: 'Path to Dockerfile relative to repository root'
    
  # Optional parameters with defaults
  - name: imageTag
    type: string
    displayName: 'Docker image tag'
    default: '$(Build.BuildNumber)'
    
  - name: buildContext
    type: string
    displayName: 'Docker build context path'
    default: '$(Build.SourcesDirectory)'
    
  - name: buildArgs
    type: string
    displayName: 'Docker build arguments (space-separated)'
    default: ''
    
  - name: artifactName
    type: string
    displayName: 'Pipeline artifact name'
    default: 'docker-images'
    
  - name: enableCompression
    type: boolean
    displayName: 'Enable gzip compression of tar file'
    default: true
    
  - name: runTests
    type: boolean
    displayName: 'Run basic container tests'
    default: true
    
  - name: testCommand
    type: string
    displayName: 'Command to test the container (optional)'
    default: '--version'

jobs:
- job: BuildDockerImage
  displayName: 'Build Docker Image'
  pool:
    vmImage: 'ubuntu-latest'
  variables:
    dockerTarFileName: '$-$.tar'
    fullImageName: '$:$'
  steps:
  - checkout: self
    displayName: 'Checkout source code'

  - script: |
      set -e
      echo "========================================"
      echo "Docker Build Information"
      echo "========================================"
      echo "Pipeline: $(Build.DefinitionName)"
      echo "Build Number: $(Build.BuildNumber)"
      echo "Source Branch: $(Build.SourceBranchName)"
      echo "Commit ID: $(Build.SourceVersion)"
      echo ""
      echo "Docker Configuration:"
      echo "- Image Name: $"
      echo "- Image Tag: $"
      echo "- Full Image: $(fullImageName)"
      echo "- Dockerfile Path: $"
      echo "- Build Context: $"
      echo "- Build Args: $"
      echo ""
      echo "Build Options:"
      echo "- Run Tests: $"
      echo "- Enable Compression: $"
      echo ""
      echo "System Information:"
      docker --version
      echo "Available disk space:"
      df -h
      echo "========================================"
    displayName: 'Display build information'


  # Validate Dockerfile exists
  - script: |
      set -e
      if [ ! -f "$" ]; then
        echo "Error: Dockerfile not found at $"
        exit 1
      fi
      echo "✓ Dockerfile found at $"
      
      # Show Dockerfile contents (first 20 lines)
      echo ""
      echo "Dockerfile preview:"
      echo "==================="
      head -20 "$"
      echo "==================="
    displayName: 'Validate Dockerfile'
  
  # Build Docker image
  - script: |
      set -e
      echo "Building Docker image: $(fullImageName)"
      echo "Context: $"
      
      # Prepare build command
      BUILD_CMD="docker build -t $(fullImageName) -f $"
      
      # Add build args if provided
      if [ -n "$" ]; then
        for arg in $; do
          BUILD_CMD="$BUILD_CMD --build-arg $arg"
        done
        echo "Build arguments: $"
      fi
      
      # Add build context
      BUILD_CMD="$BUILD_CMD $"
      
      echo "Executing: $BUILD_CMD"
      eval $BUILD_CMD
      
      # Also tag as latest for convenience
      docker tag $(fullImageName) $:latest
      
      # Display built images
      echo ""
      echo "Built images:"
      docker images | grep $
    displayName: 'Build Docker image'
  
  # Test the Docker image (if enabled)
  - script: |
      set -e
      echo "Testing Docker image: $(fullImageName)"
      
      # Basic image inspection
      echo "Image details:"
      docker inspect $(fullImageName) --format=''
      docker inspect $(fullImageName) --format=''
      
      # Run test command if provided
      if [ -n "$" ] && [ "$" != "none" ]; then
        echo "Running test command: $"
        docker run --rm $(fullImageName) $ || {
          echo "⚠️ Test command failed, but continuing build..."
        }
      fi
      
      # Check image size
      echo ""
      echo "Image size information:"
      docker images $(fullImageName) --format "table \t\t\t"
      
      # Check for security issues (basic)
      echo ""
      echo "Basic security check:"
      docker run --rm $(fullImageName) whoami 2>/dev/null || echo "Cannot check user (expected for some images)"
    displayName: 'Test Docker image'
    condition: eq($, true)
  
  # Save Docker image to tar file
  - script: |
      set -e
      echo "Saving Docker image to tar file..."
      mkdir -p $(Agent.TempDirectory)/docker-artifacts
      
      # Save both tagged version and latest
      echo "Saving images: $(fullImageName) and $:latest"
      docker save $(fullImageName) $:latest -o $(Agent.TempDirectory)/docker-artifacts/$(dockerTarFileName)
      
      # Display file info
      echo ""
      echo "Artifact created:"
      ls -lh $(Agent.TempDirectory)/docker-artifacts/
      echo "Docker image saved as: $(dockerTarFileName)"
      
      file_size=$(du -h $(Agent.TempDirectory)/docker-artifacts/$(dockerTarFileName) | cut -f1)
      echo "File size: $file_size"
      
      # Store file size for use in metadata
      echo "##vso[task.setvariable variable=dockerTarFileSize]$file_size"
    displayName: 'Save Docker image to tar file'
  
  # Create compressed version (if enabled)
  - script: |
      set -e
      echo "Creating compressed version..."
      cd $(Agent.TempDirectory)/docker-artifacts

      # Compress the tar file
      echo "Compressing $(dockerTarFileName)..."
      gzip -c $(dockerTarFileName) > $(dockerTarFileName).gz

      # Display sizes (use stat -c on Linux instead of -f)
      original_size=$(stat -c%s $(dockerTarFileName))
      compressed_size=$(stat -c%s $(dockerTarFileName).gz)

      echo "Compression results:"
      echo "- Original size: $(du -h $(dockerTarFileName) | cut -f1)"
      echo "- Compressed size: $(du -h $(dockerTarFileName).gz | cut -f1)"

      # Calculate compression ratio
      ratio=$(echo "scale=1; $compressed_size * 100 / $original_size" | bc -l)
      echo "- Compression ratio: ${ratio}%"

      echo ""
      echo "All artifacts:"
      ls -lh
    displayName: 'Create compressed version'
    condition: eq($, true)
  
  # Create metadata file
  - script: |
      set -e
      echo "Creating metadata file..."
      metadata_file="$(Agent.TempDirectory)/docker-artifacts/image-info.txt"
      
      cat > "$metadata_file" << EOF
      Docker Image Build Information
      ==============================
      
      Build Details:
      --------------
      Image Name: $
      Image Tag: $
      Full Image: $(fullImageName)
      Build Number: $(Build.BuildNumber)
      Build Date: $(date -u '+%Y-%m-%d %H:%M:%S UTC')
      Source Branch: $(Build.SourceBranchName)
      Commit ID: $(Build.SourceVersion)
      Pipeline: $(Build.DefinitionName)
      
      Configuration:
      --------------
      Dockerfile Path: $
      Build Context: $
      Build Args: $
      
      Artifact Details:
      -----------------
      Tar File: $(dockerTarFileName)
      File Size: $(dockerTarFileSize)
      Compressed: $
      
      Usage Instructions:
      ===================
      1. Download the artifact from Azure DevOps
      2. Extract the tar file from the artifact zip
      3. Load into Docker: 
         docker load -i $(dockerTarFileName)
      4. Verify images: 
         docker images | grep $
      5. Run container: 
         docker run --rm $(fullImageName)
      
      Available tags after import:
      - $(fullImageName)
      - $:latest
      EOF
      
      echo "Metadata file created:"
      cat "$metadata_file"
    displayName: 'Create metadata file'
  
  # Publish Docker image as pipeline artifact
  - task: PublishPipelineArtifact@1
    inputs:
      targetPath: '$(Agent.TempDirectory)/docker-artifacts'
      artifactName: '$-$'
      publishLocation: 'pipeline'
    displayName: 'Publish Docker image artifact'
  
  # Clean up local Docker images to save space
  - script: |
      set -e
      echo "Cleaning up local Docker images..."
      docker rmi $(fullImageName) $:latest || true
      
      # Clean up any dangling images
      docker system prune -f
      
      echo "Remaining disk space:"
      df -h
    displayName: 'Clean up Docker images'
    condition: always()

steps:
# Step 1: SSH to remote server and extract nginx logs to a file
- task: SSH@0
  displayName: 'Extract Nginx Logs to File'
  inputs:
    sshEndpoint: 'MySSHConnection'
    runOptions: 'inline'
    inline: |
      cd /path/to/your/compose/directory
      
      # Create logs directory if it doesn't exist
      mkdir -p /tmp/pipeline-logs
      
      # Extract nginx logs with timestamp
      echo "=== Nginx Logs - $(date) ===" > /tmp/pipeline-logs/nginx-logs.txt
      podman-compose logs nginx --tail=1000 >> /tmp/pipeline-logs/nginx-logs.txt
      
      # Extract error logs separately
      echo "" >> /tmp/pipeline-logs/nginx-logs.txt
      echo "=== Nginx Error Logs ===" >> /tmp/pipeline-logs/nginx-logs.txt
      podman-compose logs nginx 2>&1 | grep -i error >> /tmp/pipeline-logs/nginx-logs.txt || echo "No errors found" >> /tmp/pipeline-logs/nginx-logs.txt
      
      # Container status for context
      echo "" >> /tmp/pipeline-logs/nginx-logs.txt
      echo "=== Container Status ===" >> /tmp/pipeline-logs/nginx-logs.txt
      podman-compose ps >> /tmp/pipeline-logs/nginx-logs.txt
      
      # Show file was created
      ls -la /tmp/pipeline-logs/
      echo "Log file size: $(wc -l < /tmp/pipeline-logs/nginx-logs.txt) lines"

# Step 2: Copy the log file from remote server to pipeline agent
- task: CopyFilesOverSSH@0
  displayName: 'Download Nginx Logs from Remote Server'
  inputs:
    sshEndpoint: 'MySSHConnection'
    sourceFolder: '/tmp/pipeline-logs'
    contents: '*.txt'
    targetFolder: '$(Pipeline.Workspace)/nginx-logs'
    isDownloadFiles: true  # This is key - it downloads FROM the remote server
    cleanTargetFolder: true

# Step 3: Publish logs as pipeline artifact
- task: PublishPipelineArtifact@1
  displayName: 'Publish Nginx Logs as Artifact'
  inputs:
    targetPath: '$(Pipeline.Workspace)/nginx-logs'
    artifact: 'nginx-logs'
    publishLocation: 'pipeline'
  condition: always()  # Publish even if previous steps failed