mirror of
https://github.com/Grace-Solutions/PSMinIO.git
synced 2026-07-26 14:58:13 +00:00
PSMinIO Developer
402 lines
12 KiB
Markdown
402 lines
12 KiB
Markdown
# PSMinIO Examples
|
|
|
|
This document contains practical examples for using the PSMinIO PowerShell module.
|
|
|
|
## Basic Setup and Configuration
|
|
|
|
### Example 1: Initial Setup for Local MinIO
|
|
|
|
```powershell
|
|
# Import the module
|
|
Import-Module .\PSMinIO.psd1
|
|
|
|
# Configure for local MinIO instance
|
|
Set-MinIOConfig -Endpoint "localhost:9000" `
|
|
-AccessKey "minioadmin" `
|
|
-SecretKey "minioadmin" `
|
|
-NoSSL `
|
|
-TestConnection `
|
|
-SaveToDisk
|
|
|
|
# Verify configuration
|
|
Get-MinIOConfig -Detailed
|
|
```
|
|
|
|
### Example 2: Production Setup with SSL
|
|
|
|
```powershell
|
|
# Configure for production MinIO cluster
|
|
Set-MinIOConfig -Endpoint "minio.company.com:9000" `
|
|
-AccessKey $env:MINIO_ACCESS_KEY `
|
|
-SecretKey $env:MINIO_SECRET_KEY `
|
|
-UseSSL `
|
|
-Region "us-east-1" `
|
|
-TimeoutSeconds 60 `
|
|
-TestConnection
|
|
|
|
# Test the connection
|
|
Get-MinIOConfig -TestConnection
|
|
```
|
|
|
|
## Bucket Management Examples
|
|
|
|
### Example 3: Creating and Managing Buckets
|
|
|
|
```powershell
|
|
# Create buckets for different purposes
|
|
New-MinIOBucket -BucketName "company-documents" -Region "us-east-1" -PassThru
|
|
New-MinIOBucket -BucketName "user-uploads" -Region "us-west-2" -PassThru
|
|
New-MinIOBucket -BucketName "application-logs" -Region "eu-west-1" -PassThru
|
|
|
|
# List all buckets with statistics
|
|
Get-MinIOBucket -IncludeStatistics
|
|
|
|
# Check if specific buckets exist
|
|
$buckets = @("company-documents", "user-uploads", "temp-bucket")
|
|
foreach ($bucket in $buckets) {
|
|
$exists = Test-MinIOBucketExists -BucketName $bucket
|
|
Write-Host "Bucket '$bucket' exists: $exists"
|
|
}
|
|
```
|
|
|
|
### Example 4: Bucket Cleanup
|
|
|
|
```powershell
|
|
# Find and remove temporary buckets
|
|
Get-MinIOBucket | Where-Object { $_.Name -like "temp-*" } | ForEach-Object {
|
|
Write-Host "Removing temporary bucket: $($_.Name)"
|
|
Remove-MinIOBucket -BucketName $_.Name -RemoveObjects -Force
|
|
}
|
|
|
|
# Remove old test buckets (older than 30 days)
|
|
Get-MinIOBucket | Where-Object {
|
|
$_.Name -like "test-*" -and $_.Created -lt (Get-Date).AddDays(-30)
|
|
} | ForEach-Object {
|
|
Write-Host "Removing old test bucket: $($_.Name) (Created: $($_.Created))"
|
|
Remove-MinIOBucket -BucketName $_.Name -RemoveObjects -Force
|
|
}
|
|
```
|
|
|
|
## File Upload and Download Examples
|
|
|
|
### Example 5: Bulk File Upload
|
|
|
|
```powershell
|
|
# Upload all PDF files from a directory
|
|
$sourceDir = "C:\Documents\Reports"
|
|
$bucketName = "company-documents"
|
|
|
|
Get-ChildItem -Path $sourceDir -Filter "*.pdf" -Recurse | ForEach-Object {
|
|
$relativePath = $_.FullName.Substring($sourceDir.Length + 1).Replace('\', '/')
|
|
$objectName = "reports/$relativePath"
|
|
|
|
Write-Host "Uploading: $($_.Name) -> $objectName"
|
|
|
|
try {
|
|
New-MinIOObject -BucketName $bucketName `
|
|
-ObjectName $objectName `
|
|
-FilePath $_.FullName `
|
|
-Verbose
|
|
Write-Host "✓ Successfully uploaded: $($_.Name)" -ForegroundColor Green
|
|
} catch {
|
|
Write-Host "✗ Failed to upload: $($_.Name) - $($_.Exception.Message)" -ForegroundColor Red
|
|
}
|
|
}
|
|
```
|
|
|
|
### Example 6: Backup Script
|
|
|
|
```powershell
|
|
# Daily backup script
|
|
param(
|
|
[Parameter(Mandatory)]
|
|
[string]$SourcePath,
|
|
|
|
[Parameter(Mandatory)]
|
|
[string]$BucketName,
|
|
|
|
[string]$BackupPrefix = "backups"
|
|
)
|
|
|
|
$timestamp = Get-Date -Format "yyyy-MM-dd_HH-mm-ss"
|
|
$backupFolder = "$BackupPrefix/$timestamp"
|
|
|
|
Write-Host "Starting backup of '$SourcePath' to bucket '$BucketName'"
|
|
|
|
# Create a compressed archive
|
|
$tempZip = "$env:TEMP\backup_$timestamp.zip"
|
|
Compress-Archive -Path $SourcePath -DestinationPath $tempZip -Force
|
|
|
|
try {
|
|
# Upload the backup
|
|
$objectName = "$backupFolder/backup.zip"
|
|
New-MinIOObject -BucketName $BucketName `
|
|
-ObjectName $objectName `
|
|
-FilePath $tempZip `
|
|
-PassThru
|
|
|
|
Write-Host "✓ Backup completed successfully" -ForegroundColor Green
|
|
|
|
# Clean up old backups (keep last 7 days)
|
|
$cutoffDate = (Get-Date).AddDays(-7)
|
|
Get-MinIOObject -BucketName $BucketName -Prefix $BackupPrefix |
|
|
Where-Object { $_.LastModified -lt $cutoffDate } |
|
|
ForEach-Object {
|
|
Write-Host "Removing old backup: $($_.Name)"
|
|
Remove-MinIOObject -BucketName $BucketName -ObjectName $_.Name -Force
|
|
}
|
|
|
|
} finally {
|
|
# Clean up temporary file
|
|
if (Test-Path $tempZip) {
|
|
Remove-Item $tempZip -Force
|
|
}
|
|
}
|
|
```
|
|
|
|
### Example 7: Bulk Download
|
|
|
|
```powershell
|
|
# Download all objects with specific prefix
|
|
$bucketName = "company-documents"
|
|
$prefix = "reports/2025/"
|
|
$downloadDir = "C:\Downloads\Reports"
|
|
|
|
# Ensure download directory exists
|
|
if (!(Test-Path $downloadDir)) {
|
|
New-Item -ItemType Directory -Path $downloadDir -Force
|
|
}
|
|
|
|
# Get all objects with the prefix
|
|
$objects = Get-MinIOObject -BucketName $bucketName -Prefix $prefix
|
|
|
|
Write-Host "Found $($objects.Count) objects to download"
|
|
|
|
foreach ($obj in $objects) {
|
|
# Skip directories
|
|
if ($obj.IsDirectory) { continue }
|
|
|
|
# Create local file path
|
|
$relativePath = $obj.Name.Substring($prefix.Length)
|
|
$localPath = Join-Path $downloadDir $relativePath.Replace('/', '\')
|
|
$localDir = Split-Path $localPath -Parent
|
|
|
|
# Ensure local directory exists
|
|
if (!(Test-Path $localDir)) {
|
|
New-Item -ItemType Directory -Path $localDir -Force
|
|
}
|
|
|
|
Write-Host "Downloading: $($obj.Name) -> $localPath"
|
|
|
|
try {
|
|
Get-MinIOObjectContent -BucketName $bucketName `
|
|
-ObjectName $obj.Name `
|
|
-FilePath $localPath `
|
|
-Force
|
|
Write-Host "✓ Downloaded: $($obj.GetFileName())" -ForegroundColor Green
|
|
} catch {
|
|
Write-Host "✗ Failed to download: $($obj.Name) - $($_.Exception.Message)" -ForegroundColor Red
|
|
}
|
|
}
|
|
```
|
|
|
|
## Security and Policy Examples
|
|
|
|
### Example 8: Setting Up Public Read Access
|
|
|
|
```powershell
|
|
# Create a bucket for public assets
|
|
New-MinIOBucket -BucketName "public-assets"
|
|
|
|
# Set read-only policy for public access
|
|
Set-MinIOBucketPolicy -BucketName "public-assets" `
|
|
-CannedPolicy "ReadOnly" `
|
|
-Prefix "*"
|
|
|
|
# Verify the policy
|
|
Get-MinIOBucketPolicy -BucketName "public-assets" -AsObject
|
|
```
|
|
|
|
### Example 9: Custom Policy for Upload-Only Access
|
|
|
|
```powershell
|
|
$uploadOnlyPolicy = @"
|
|
{
|
|
"Version": "2012-10-17",
|
|
"Statement": [
|
|
{
|
|
"Effect": "Allow",
|
|
"Principal": {"AWS": "*"},
|
|
"Action": ["s3:PutObject"],
|
|
"Resource": ["arn:aws:s3:::user-uploads/uploads/*"]
|
|
}
|
|
]
|
|
}
|
|
"@
|
|
|
|
Set-MinIOBucketPolicy -BucketName "user-uploads" `
|
|
-PolicyJson $uploadOnlyPolicy
|
|
|
|
# Test the policy
|
|
Get-MinIOBucketPolicy -BucketName "user-uploads" -PrettyPrint
|
|
```
|
|
|
|
## Monitoring and Statistics Examples
|
|
|
|
### Example 10: Storage Usage Report
|
|
|
|
```powershell
|
|
# Generate comprehensive storage report
|
|
$stats = Get-MinIOStats -IncludeBucketDetails -IncludeObjectCounts
|
|
|
|
Write-Host "=== MinIO Storage Report ===" -ForegroundColor Cyan
|
|
Write-Host "Generated: $(Get-Date)" -ForegroundColor Gray
|
|
Write-Host ""
|
|
|
|
Write-Host "Overall Statistics:" -ForegroundColor Yellow
|
|
Write-Host " Total Buckets: $($stats.TotalBuckets)"
|
|
Write-Host " Total Objects: $($stats.TotalObjects)"
|
|
Write-Host " Total Size: $($stats.TotalSizeFormatted)"
|
|
Write-Host " Average Object Size: $($stats.AverageObjectSizeFormatted)"
|
|
Write-Host ""
|
|
|
|
Write-Host "Bucket Details:" -ForegroundColor Yellow
|
|
$stats.BucketDetails | Sort-Object Size -Descending | ForEach-Object {
|
|
Write-Host " $($_.Name):"
|
|
Write-Host " Objects: $($_.ObjectCount)"
|
|
Write-Host " Size: $($_.SizeFormatted)"
|
|
Write-Host " Created: $($_.Created)"
|
|
Write-Host ""
|
|
}
|
|
```
|
|
|
|
### Example 11: Health Check Script
|
|
|
|
```powershell
|
|
# MinIO health check script
|
|
function Test-MinIOHealth {
|
|
param(
|
|
[string]$TestBucketName = "health-check-$(Get-Date -Format 'yyyyMMdd')"
|
|
)
|
|
|
|
$results = @{
|
|
ConfigurationValid = $false
|
|
ConnectionSuccessful = $false
|
|
BucketOperations = $false
|
|
ObjectOperations = $false
|
|
OverallHealth = $false
|
|
}
|
|
|
|
try {
|
|
# Test 1: Configuration
|
|
$config = Get-MinIOConfig
|
|
$results.ConfigurationValid = $config.IsValid
|
|
Write-Host "✓ Configuration is valid" -ForegroundColor Green
|
|
|
|
# Test 2: Connection
|
|
$connectionTest = Get-MinIOConfig -TestConnection
|
|
$results.ConnectionSuccessful = $connectionTest.ConnectionStatus -eq "Success"
|
|
Write-Host "✓ Connection successful" -ForegroundColor Green
|
|
|
|
# Test 3: Bucket operations
|
|
New-MinIOBucket -BucketName $TestBucketName -Force | Out-Null
|
|
$bucketExists = Test-MinIOBucketExists -BucketName $TestBucketName
|
|
$results.BucketOperations = $bucketExists
|
|
Write-Host "✓ Bucket operations working" -ForegroundColor Green
|
|
|
|
# Test 4: Object operations
|
|
$testFile = "$env:TEMP\minio-health-test.txt"
|
|
"Health check test file - $(Get-Date)" | Out-File -FilePath $testFile
|
|
|
|
New-MinIOObject -BucketName $TestBucketName `
|
|
-ObjectName "health-test.txt" `
|
|
-FilePath $testFile | Out-Null
|
|
|
|
$objects = Get-MinIOObject -BucketName $TestBucketName -ObjectName "health-test.txt"
|
|
$results.ObjectOperations = $objects.Count -eq 1
|
|
Write-Host "✓ Object operations working" -ForegroundColor Green
|
|
|
|
# Cleanup
|
|
Remove-MinIOObject -BucketName $TestBucketName -ObjectName "health-test.txt" -Force
|
|
Remove-MinIOBucket -BucketName $TestBucketName -Force
|
|
Remove-Item $testFile -Force
|
|
|
|
$results.OverallHealth = $results.ConfigurationValid -and
|
|
$results.ConnectionSuccessful -and
|
|
$results.BucketOperations -and
|
|
$results.ObjectOperations
|
|
|
|
Write-Host "✓ Overall health check passed" -ForegroundColor Green
|
|
|
|
} catch {
|
|
Write-Host "✗ Health check failed: $($_.Exception.Message)" -ForegroundColor Red
|
|
}
|
|
|
|
return $results
|
|
}
|
|
|
|
# Run health check
|
|
Test-MinIOHealth
|
|
```
|
|
|
|
## Advanced Automation Examples
|
|
|
|
### Example 12: Log Rotation and Archival
|
|
|
|
```powershell
|
|
# Automated log rotation script
|
|
param(
|
|
[string]$LogBucket = "application-logs",
|
|
[int]$RetentionDays = 90,
|
|
[string]$ArchiveBucket = "archived-logs"
|
|
)
|
|
|
|
$cutoffDate = (Get-Date).AddDays(-$RetentionDays)
|
|
|
|
Write-Host "Starting log rotation process..."
|
|
Write-Host "Archiving logs older than: $cutoffDate"
|
|
|
|
# Get old log files
|
|
$oldLogs = Get-MinIOObject -BucketName $LogBucket |
|
|
Where-Object { $_.LastModified -lt $cutoffDate -and !$_.IsDirectory }
|
|
|
|
Write-Host "Found $($oldLogs.Count) log files to archive"
|
|
|
|
foreach ($log in $oldLogs) {
|
|
try {
|
|
# Download log file
|
|
$tempFile = "$env:TEMP\$($log.GetFileName())"
|
|
Get-MinIOObjectContent -BucketName $LogBucket `
|
|
-ObjectName $log.Name `
|
|
-FilePath $tempFile
|
|
|
|
# Compress the log file
|
|
$compressedFile = "$tempFile.gz"
|
|
# Note: You would use a compression library here
|
|
# For this example, we'll just rename
|
|
Move-Item $tempFile $compressedFile
|
|
|
|
# Upload to archive bucket with date prefix
|
|
$archiveObjectName = "archived/$(Get-Date $log.LastModified -Format 'yyyy/MM/dd')/$($log.GetFileName()).gz"
|
|
New-MinIOObject -BucketName $ArchiveBucket `
|
|
-ObjectName $archiveObjectName `
|
|
-FilePath $compressedFile
|
|
|
|
# Remove original log file
|
|
Remove-MinIOObject -BucketName $LogBucket -ObjectName $log.Name -Force
|
|
|
|
# Clean up temp file
|
|
Remove-Item $compressedFile -Force
|
|
|
|
Write-Host "✓ Archived: $($log.Name)" -ForegroundColor Green
|
|
|
|
} catch {
|
|
Write-Host "✗ Failed to archive: $($log.Name) - $($_.Exception.Message)" -ForegroundColor Red
|
|
}
|
|
}
|
|
|
|
Write-Host "Log rotation completed"
|
|
```
|
|
|
|
These examples demonstrate the practical usage of PSMinIO for various scenarios including setup, file management, security configuration, monitoring, and automation. Each example includes error handling and best practices for production use.
|