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