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