Help me schrijven van Ruby-code voor automatisering van DevOps-taken
description
Met deze prompt krijg je een op maat gemaakt Ruby-script dat specifieke DevOps-taken automatiseert, waardoor je tijd bespaart en menselijke fouten vermindert. Het helpt je ook best practices toe te passen en robuuste foutafhandeling te integreren, wat veiliger en efficiënter is dan handmatige processen.
prompt
Help me een Ruby-script te schrijven voor het automatiseren van de volgende DevOps-taak: <beschrijf de taak, bijvoorbeeld deployment, serverconfiguratie, monitoring>. Geef details over mijn infr ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Hier is een voorbeeld Ruby-script dat je kunt gebruiken om je Rails-applicatie te deployen naar een AWS EC2 Ubuntu 20.04 server met Docker. Het script maakt gebruik van SSH voor remote commands, foutafhandeling en volgt best practices voor betrouwbaarheid.
**Benodigdheden:**
- Ruby geïnstalleerd op je lokale machine
- Gem `net-ssh` voor SSH-communicatie
- Een SSH-sleutel om verbinding te maken met je server
- Dockerfile en Docker-compose bestand in je project voor containerisatie
```ruby
require 'net/ssh'
require 'logger'
# Configuratie
HOST = 'jouw.ec2.public.ip'
USER = 'ubuntu'
SSH_KEY_PATH = '~/.ssh/jouw_ssh_key.pem'
REPO_PATH = '/pad/naar/je/repository'
BRANCH = 'main' # of je deploy branch
LOG_FILE = 'deploy.log'
logger = Logger.new(LOG_FILE)
def execute_ssh_command(host, user, key_path, command, logger)
begin
Net::SSH.start(host, user, keys: [File.expand_path(key_path)], paranoid: false) do |ssh|
logger.info("Executing: #{command}")
output = ssh.exec!(command)
unless ssh.last_exit_status == 0
raise "Command failed: #{command}"
end
logger.info("Output: #{output}")
return output
end
rescue => e
logger.error("SSH command '#{command}' failed: #{e.message}")
exit 1
end
end
# Stap 1: Update de server en haal de nieuwste code
def update_code(host, user, key_path, repo_path, branch, logger)
execute_ssh_command(host, user, key_path, "cd #{repo_path} && git fetch && git checkout #{branch} && git pull origin #{branch}", logger)
end
# Stap 2: Bouw en start Docker containers
def build_and_deploy_docker(host, user, key_path, repo_path, logger)
# Optioneel: pull nieuwste Docker images of build lokaal en push
# Hier gaan we ervan uit dat je een docker-compose.yml hebt
commands = [
"cd #{repo_path}",
"docker-compose down",
"docker-compose build",
"docker-compose up -d"
].join(' && ')
execute_ssh_command(host, user, key_path, commands, logger)
end
# Stap 3: Controleer of de app draait
def check_app(host, user, key_path, logger)
health_check_url = 'http://localhost:3000/health' # pas aan naar je health endpoint
begin
output = execute_ssh_command(host, user, key_path, "curl -s -o /dev/null -w \"%{http_code}\" #{health_check_url}", logger)
if output.strip == "200"
logger.info("De applicatie draait succesvol.")
else
raise "Health check failed met status #{output.strip}"
end
rescue => e
logger.error("Applicatie controle mislukt: #{e.message}")
exit 1
end
end
# Deployment proces
logger.info("Start deployment...")
update_code(HOST, USER, SSH_KEY_PATH, REPO_PATH, BRANCH, logger)
build_and_deploy_docker(HOST, USER, SSH_KEY_PATH, REPO_PATH, logger)
check_app(HOST, USER, SSH_KEY_PATH, logger)
logger.info("Deployment voltooid!")
```
### Belangrijke opmerkingen:
- Pas `HOST`, `USER`, `SSH_KEY_PATH`, `REPO_PATH` en andere variabelen aan jouw omgeving aan.
- Zorg dat je op de server Docker en Docker Compose hebt geïnstalleerd.
- Je kunt de health check URL aanpassen naar een endpoint dat je hebt ingesteld in je Rails-app.
- Overweeg gebruik te maken van CI/CD tools zoals Jenkins, GitHub Actions of GitLab CI voor meer geautomatiseerde workflows met minder handmatige scripts.
- Voor meer betrouwbaarheid kun je foutafhandeling uitbreiden, bijvoorbeeld retries toevoegen.
**Tips voor best practices:**
- Gebruik SSH-agent of beveiligde SSH-sleutels.
- Voer tests uit voor je deployment.
- Maak backups of gebruik zero-downtime deployment technieken.
- Log alle stappen en fouten voor troubleshooting.
Wil je dat ik het script verder aanpas voor jouw specifieke situatie of extra functionaliteiten toevoeg?
provider: deepseek
model: deepseek-chat
Zeker, ik help je een robuust Ruby-script te schrijven voor je Rails deployment. Hier is een complete oplossing met best practices:
```ruby
#!/usr/bin/env ruby
# deploy.rb - Automatische deployment script voor Rails applicatie naar Ubuntu/Docker
require 'fileutils'
require 'open3'
require 'json'
require 'logger'
class DeploymentError < StandardError; end
class RailsDeployer
def initialize
@logger = Logger.new($stdout)
@logger.level = Logger::INFO
@logger.formatter = proc do |severity, datetime, progname, msg|
"#{datetime.strftime('%Y-%m-%d %H:%M:%S')} #{severity}: #{msg}\n"
end
end
def run
log_header("Starting Rails Deployment")
begin
validate_environment
setup_ssh
deploy_application
health_check
log_success("Deployment completed successfully!")
rescue DeploymentError => e
@logger.error("Deployment failed: #{e.message}")
exit 1
rescue => e
@logger.error("Unexpected error: #{e.message}")
@logger.error(e.backtrace.join("\n"))
exit 1
end
end
private
def validate_environment
@logger.info("Validating environment variables...")
required_vars = %w[AWS_EC2_HOST AWS_SSH_KEY_PATH DOCKER_IMAGE_TAG]
missing_vars = required_vars.reject { |var| ENV[var] }
if missing_vars.any?
raise DeploymentError, "Missing environment variables: #{missing_vars.join(', ')}"
end
unless File.exist?(ENV['AWS_SSH_KEY_PATH'])
raise DeploymentError, "SSH key not found at: #{ENV['AWS_SSH_KEY_PATH']}"
end
end
def setup_ssh
@logger.info("Setting up SSH connection...")
# Zorg dat de SSH key de correcte permissions heeft
FileUtils.chmod(0600, ENV['AWS_SSH_KEY_PATH'])
# Test SSH connectivity
ssh_command = build_ssh_command("echo 'SSH connection test successful'")
execute_local_command(ssh_command)
end
def deploy_application
log_header("Deploying Application")
# 1. Pull latest Docker image
@logger.info("Pulling Docker image...")
pull_command = build_ssh_command("docker pull #{ENV['DOCKER_IMAGE_TAG']}")
execute_local_command(pull_command)
# 2. Stop existing container
@logger.info("Stopping existing container...")
stop_command = build_ssh_command("docker stop rails-app || true")
execute_local_command(stop_command)
# 3. Remove old container
@logger.info("Removing old container...")
remove_command = build_ssh_command("docker rm rails-app || true")
execute_local_command(remove_command)
# 4. Run new container
@logger.info("Starting new container...")
run_command = build_ssh_command(<<~CMD
docker run -d \\
--name rails-app \\
--restart unless-stopped \\
-p 3000:3000 \\
-e RAILS_ENV=production \\
-e DATABASE_URL=#{ENV['DATABASE_URL']} \\
-e SECRET_KEY_BASE=#{ENV['SECRET_KEY_BASE']} \\
#{ENV['DOCKER_IMAGE_TAG']}
CMD
)
execute_local_command(run_command)
# 5. Run database migrations (indien nodig)
if ENV['RUN_MIGRATIONS'] == 'true'
@logger.info("Running database migrations...")
migrate_command = build_ssh_command("docker exec rails-app bundle exec rails db:migrate")
execute_local_command(migrate_command)
end
end
def health_check
@logger.info("Performing health check...")
# Wacht tot de applicatie ready is
max_attempts = 10
attempt = 1
while attempt <= max_attempts
@logger.info("Health check attempt #{attempt}/#{max_attempts}")
health_cmd = build_ssh_command("curl -f http://localhost:3000/health || exit 1")
success = execute_local_command(health_cmd, false)
if success
@logger.info("Health check passed!")
return
end
sleep(5)
attempt += 1
end
raise DeploymentError, "Health check failed after #{max_attempts} attempts"
end
def build_ssh_command(command)
"ssh -o StrictHostKeyChecking=no -i #{ENV['AWS_SSH_KEY_PATH']} ubuntu@#{ENV['AWS_EC2_HOST']} '#{command}'"
end
def execute_local_command(command, raise_on_error = true)
@logger.debug("Executing: #{command}")
stdout, stderr, status = Open3.capture3(command)
if status.success?
@logger.debug(stdout) unless stdout.empty?
true
else
@logger.error("Command failed: #{command}")
@logger.error("STDERR: #{stderr}")
raise DeploymentError, "Command execution failed" if raise_on_error
false
end
end
def log_header(message)
@logger.info("=" * 60)
@logger.info(message)
@logger.info("=" * 60)
end
def log_success(message)
@logger.info("✅ " + message)
end
end
# Main execution
if __FILE__ == $0
deployer = RailsDeployer.new
deployer.run
end
```
## Benodigde Environment Variables:
Maak een `.env` bestand aan:
```bash
# AWS Configuratie
AWS_EC2_HOST=your-ec2-public-ip
AWS_SSH_KEY_PATH=path/to/your/ssh/key.pem
# Docker Configuratie
DOCKER_IMAGE_TAG=your-docker-repo/rails-app:latest
# Application Configuratie
DATABASE_URL=postgresql://user:pass@host/dbname
SECRET_KEY_BASE=your-secret-key-base
RUN_MIGRATIONS=true
```
## Gebruik:
```bash
# Maak het script uitvoerbaar
chmod +x deploy.rb
# Set environment variables
export $(cat .env | xargs)
# Run deployment
./deploy.rb
```
## Aanbevolen Best Practices:
1. **Infrastructure as Code**: Overweeg Terraform of CloudFormation voor server provisioning
2. **CI/CD Integration**: Integreer met GitHub Actions/GitLab CI
3. **Rollback Mechanism**: Voeg rollback functionaliteit toe
4. **Monitoring**: Voeg monitoring checks toe (Prometheus/DataDog)
5. **Secrets Management**: Gebruik AWS Secrets Manager of HashiCorp Vault
6. **Backups**: Zorg voor database backups voor deployment
## Extra Beveiliging:
```ruby
# Voeg toe aan validate_environment
def validate_ssh_security
# Controleer of SSH key niet wereld-leesbaar is
key_permissions = File.stat(ENV['AWS_SSH_KEY_PATH']).mode.to_s(8)[-3..-1]
if key_permissions != '600'
raise DeploymentError, "SSH key moet 600 permissions hebben (huidig: #{key_permissions})"
end
end
```
Dit script volgt enterprise best practices voor error handling, logging en beveiliging.
error: Generation failed [deepseek] prompt_id=3236 locale=en err=DeepSeek connection/timeout