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