$ certbot renew --nginx --quiet
$ kubectl apply -f deployment.yaml
// TODO: implement circuit breaker pattern
await Promise.all(tasks.map(t => t.execute()));
child_process.exec("nginx -t", callback);
SELECT * FROM deployments WHERE status = 1;
UPDATE services SET replicas = 3 WHERE name = $1;
$ git commit -m "fix: resolve memory leak"
server.on("error", (err) => logger.fatal(err));
/* eslint-disable no-console */
func deploy(ctx context.Context) error {
UPDATE services SET replicas = 3 WHERE name = $1;
if (!token) return res.status(401).json({ error });
try { await deploy(); } catch (e) { rollback(); }
fs.writeFileSync("/tmp/config.json", data);
$ grep -rn "ERROR" /var/log/app/*.log
$ helm upgrade --install api ./chart
$ npm run build && npm run deploy
useEffect(() => { fetchData(); }, [id]);
exit 0
server.on("error", (err) => logger.fatal(err));
const [state, setState] = useState(null);
$ git push origin main --force-with-lease
class Pipeline extends EventEmitter {
while (queue.length > 0) process(queue.shift());
setInterval(() => healthCheck(), 30000);
for (let i = 0; i < nodes.length; i++) {
fs.writeFileSync("/tmp/config.json", data);
const { rows } = await pool.query(sql);
server.on("error", (err) => logger.fatal(err));
$ kubectl apply -f deployment.yaml
$ certbot renew --nginx --quiet
module.exports = { config, deploy };
$ kubectl apply -f deployment.yaml
CREATE INDEX idx_deploy ON builds (created_at);
const db = new PrismaClient();
func deploy(ctx context.Context) error {
addEventListener("DOMContentLoaded", init);
const result = await fetch(API_URL);
EXPLAIN ANALYZE SELECT * FROM metrics ORDER BY ts;
router.get("/api/v1/users", getUsers);
$ docker push registry.io/app:v2.1.0
module.exports = { config, deploy };
$ certbot renew --nginx --quiet
export default function main() {
$ git commit -m "fix: resolve memory leak"
child_process.exec("nginx -t", callback);
const hash = crypto.createHash("sha256").update(pw);
$ curl -X POST https://api.example.com/deploy
server.on("error", (err) => logger.fatal(err));
def run_pipeline(config: dict) -> None:
export default function main() {
Array.from(nodes).filter(n => n.active).map(fn);
fs.writeFileSync("/tmp/config.json", data);
// TODO: implement circuit breaker pattern
$ certbot renew --nginx --quiet
$ curl -X POST https://api.example.com/deploy
try { await deploy(); } catch (e) { rollback(); }
for (let i = 0; i < nodes.length; i++) {
export default function main() {
#!/bin/bash
EXPLAIN ANALYZE SELECT * FROM metrics ORDER BY ts;
fn main() -> Result<(), Box<dyn Error>> {
// TODO: implement circuit breaker pattern
def run_pipeline(config: dict) -> None:
CREATE INDEX idx_deploy ON builds (created_at);
try { await deploy(); } catch (e) { rollback(); }
const token = jwt.sign(payload, SECRET);
try { await deploy(); } catch (e) { rollback(); }
try { await deploy(); } catch (e) { rollback(); }
pipe(stream).on("data", chunk => buffer.push(chunk));
process.env.NODE_ENV = "production";
export default function main() {
$ git commit -m "fix: resolve memory leak"
const hash = crypto.createHash("sha256").update(pw);
const token = jwt.sign(payload, SECRET);
useEffect(() => { fetchData(); }, [id]);
// TODO: implement circuit breaker pattern
console.log("[INFO] server started on :3000");
return new Promise((resolve, reject) => {
const result = await fetch(API_URL);
async function handleRequest(req, res) {
// TODO: implement circuit breaker pattern
UPDATE services SET replicas = 3 WHERE name = $1;
app.listen(PORT, () => console.log("ready"));
const result = await fetch(API_URL);
// TODO: implement circuit breaker pattern
SELECT * FROM deployments WHERE status = 1;
child_process.exec("nginx -t", callback);
if (status === 200) return data;
$ pm2 restart ecosystem.config.js --env prod
$ ssh root@10.0.0.1 "systemctl restart app"
const app = express();
server.on("error", (err) => logger.fatal(err));
const result = await fetch(API_URL);
while (queue.length > 0) process(queue.shift());
const result = await fetch(API_URL);
await Promise.all(tasks.map(t => t.execute()));
$ docker build -t app:latest .
server.on("error", (err) => logger.fatal(err));
SELECT * FROM deployments WHERE status = 1;
addEventListener("DOMContentLoaded", init);
class Pipeline extends EventEmitter {
$ curl -X POST https://api.example.com/deploy
$ pm2 restart ecosystem.config.js --env prod
Object.keys(env).forEach(k => validate(k));
func deploy(ctx context.Context) error {
$ helm upgrade --install api ./chart
$ docker build -t app:latest .
UPDATE services SET replicas = 3 WHERE name = $1;
UPDATE services SET replicas = 3 WHERE name = $1;
if (status === 200) return data;
$ git commit -m "fix: resolve memory leak"
redis.set(`session:${id}`, JSON.stringify(user));
redis.set(`session:${id}`, JSON.stringify(user));
$ pm2 restart ecosystem.config.js --env prod
server.on("error", (err) => logger.fatal(err));
setInterval(() => healthCheck(), 30000);
export default function main() {
$ rsync -avz ./dist/ server:/var/www/html/
const db = new PrismaClient();
func deploy(ctx context.Context) error {
return new Promise((resolve, reject) => {
$ pm2 restart ecosystem.config.js --env prod
UPDATE services SET replicas = 3 WHERE name = $1;
const db = new PrismaClient();
await Promise.all(tasks.map(t => t.execute()));
$ docker push registry.io/app:v2.1.0
def run_pipeline(config: dict) -> None:
const hash = crypto.createHash("sha256").update(pw);
exit 0
const { rows } = await pool.query(sql);
Array.from(nodes).filter(n => n.active).map(fn);
SELECT * FROM deployments WHERE status = 1;
$ helm upgrade --install api ./chart
$ terraform plan -var-file=prod.tfvars
UPDATE services SET replicas = 3 WHERE name = $1;
INSERT INTO logs (msg, level) VALUES ($1, $2);
$ pm2 restart ecosystem.config.js --env prod
for (let i = 0; i < nodes.length; i++) {
redis.set(`session:${id}`, JSON.stringify(user));
app.listen(PORT, () => console.log("ready"));
$ terraform plan -var-file=prod.tfvars
import React from "react";
$ rsync -avz ./dist/ server:/var/www/html/
document.querySelector("#root").innerHTML = html;
$ tail -f /var/log/nginx/access.log
$ npm run build && npm run deploy
func deploy(ctx context.Context) error {
$ certbot renew --nginx --quiet
if (!token) return res.status(401).json({ error });
Array.from(nodes).filter(n => n.active).map(fn);
export const middleware = (req, res, next) => {
/* eslint-disable no-console */
$ certbot renew --nginx --quiet
console.log("[INFO] server started on :3000");
INSERT INTO logs (msg, level) VALUES ($1, $2);
// TODO: implement circuit breaker pattern
child_process.exec("nginx -t", callback);
$ docker push registry.io/app:v2.1.0
EXPLAIN ANALYZE SELECT * FROM metrics ORDER BY ts;
func deploy(ctx context.Context) error {
const hash = crypto.createHash("sha256").update(pw);
setInterval(() => healthCheck(), 30000);
func deploy(ctx context.Context) error {
setInterval(() => healthCheck(), 30000);
def run_pipeline(config: dict) -> None:
fs.writeFileSync("/tmp/config.json", data);
$ helm upgrade --install api ./chart
EXPLAIN ANALYZE SELECT * FROM metrics ORDER BY ts;
$ tail -f /var/log/nginx/access.log
process.env.NODE_ENV = "production";
$ docker push registry.io/app:v2.1.0
export default function main() {
$ kubectl apply -f deployment.yaml
// TODO: implement circuit breaker pattern
export default function main() {
EXPLAIN ANALYZE SELECT * FROM metrics ORDER BY ts;
try { await deploy(); } catch (e) { rollback(); }
useEffect(() => { fetchData(); }, [id]);
/* eslint-disable no-console */
export default function main() {
EXPLAIN ANALYZE SELECT * FROM metrics ORDER BY ts;
Object.keys(env).forEach(k => validate(k));
const { rows } = await pool.query(sql);
exit 0
exit 0
process.env.NODE_ENV = "production";
$ docker build -t app:latest .
while (queue.length > 0) process(queue.shift());
$ git push origin main --force-with-lease
import React from "react";
document.querySelector("#root").innerHTML = html;
$ terraform plan -var-file=prod.tfvars
CREATE INDEX idx_deploy ON builds (created_at);
$ pm2 restart ecosystem.config.js --env prod
console.log("[INFO] server started on :3000");
$ certbot renew --nginx --quiet
const db = new PrismaClient();
class Pipeline extends EventEmitter {
if (status === 200) return data;
fn main() -> Result<(), Box<dyn Error>> {
const db = new PrismaClient();
while (queue.length > 0) process(queue.shift());
$ kubectl apply -f deployment.yaml
export default function main() {
export const middleware = (req, res, next) => {
pipe(stream).on("data", chunk => buffer.push(chunk));
console.log("[INFO] server started on :3000");
const result = await fetch(API_URL);
exit 0
$ docker push registry.io/app:v2.1.0
const token = jwt.sign(payload, SECRET);
exit 0
export const middleware = (req, res, next) => {
EXPLAIN ANALYZE SELECT * FROM metrics ORDER BY ts;
process.env.NODE_ENV = "production";
/* eslint-disable no-console */
class Pipeline extends EventEmitter {
useEffect(() => { fetchData(); }, [id]);
const db = new PrismaClient();
const db = new PrismaClient();
pipe(stream).on("data", chunk => buffer.push(chunk));
module.exports = { config, deploy };
$ rsync -avz ./dist/ server:/var/www/html/
exit 0
$ git push origin main --force-with-lease
console.log("[INFO] server started on :3000");
Array.from(nodes).filter(n => n.active).map(fn);
if (!token) return res.status(401).json({ error });
Object.keys(env).forEach(k => validate(k));
/* eslint-disable no-console */
$ terraform plan -var-file=prod.tfvars
SELECT * FROM deployments WHERE status = 1;
$ npm run build && npm run deploy
router.get("/api/v1/users", getUsers);
$ certbot renew --nginx --quiet
try { await deploy(); } catch (e) { rollback(); }
$ tail -f /var/log/nginx/access.log
pipe(stream).on("data", chunk => buffer.push(chunk));
$ certbot renew --nginx --quiet
$ ssh root@10.0.0.1 "systemctl restart app"
$ grep -rn "ERROR" /var/log/app/*.log
const [state, setState] = useState(null);
const result = await fetch(API_URL);
$ ssh root@10.0.0.1 "systemctl restart app"
$ terraform plan -var-file=prod.tfvars
useEffect(() => { fetchData(); }, [id]);
def run_pipeline(config: dict) -> None:
const db = new PrismaClient();