• Înțelegerea conceptelor de bază
• Explicarea arhitecturii client-server și diferențele față de alte arhitecturi
• Definirea rolurilor clientului și serverului în contextul aplicațiilor distribuite
• Mecanisme de comunicare
• Explicarea protocoalelor de comunicație între client și server (HTTP)
• Coduri de status
• Cum funcționează cererile și răspunsurile (request-response cycle)

La job:

• “Hai să facem un MVP rapid pentru clientul X” > Flask + React/Angular
• “Trebuie să integrez API-ul ăsta de la terți” > Flask middleware
• “Avem nevoie de un microserviciu pentru feature Y” > Flask

La licență:

• Orice aplicație web cu backend custom
• Profesorii apreciază că știi să faci un backend de la zero
• Arată mai bine în licență decât Firebase (aka e ceva mai “serios”)

La interviuri:

• “Explică-mi arhitectura unui sistem client-server”
• “Cum ai implementa un REST API?”
• “Descrie-mi ciclul request-response”

Proiecte personale:

• Automatizări, scraping, boti Discord/Telegram
• Dashboard-uri pentru crypto
• Orice idee de startup

În acest laborator veți înțelege cum funcționează cu adevărat o aplicație web. Veți scrie codul care procesează cereri, validează date, interacționează cu baza de date și returnează răspunsuri - toate acestea fiind componentele esențiale ale oricărei aplicații moderne. Veți dezvolta o aplicație completă folosind arhitectura client-server. În plus față de laboratoarele anterioare, veți crea un backend REST API în Flask care gestionează task-uri (adăugare, citire, actualizare, ștergere) și le stochează într-o bază de date SQLite.

• Un server Flask funcțional cu 4-5 endpoint-uri REST
• O bază de date SQLite pentru persistența datelor
• O aplicație web client (furnizată) care interacționează cu serverul vostru
• Înțelegerea completă a ciclului request-response

Arhitectura client-server reprezintă un model de proiectare utilizat în dezvoltarea de aplicații distribuite. În acest model, două entități distincte comunică pentru a furniza funcționalitatea unei aplicații: clientul și serverul.

Clientul este entitatea care inițiază cererea către server. De obicei, acesta este un utilizator final sau un dispozitiv care solicită resurse, date sau servicii de la server. Exemple de clienți includ browsere web, aplicații mobile sau desktop-uri.

Serverul este entitatea care procesează cererea primită de la client și oferă un răspuns adecvat. Serverele stochează resursele și datele necesare și gestionează logica de afaceri a aplicației. Un server poate servi mai mulți clienți simultan.

Protocolul HTTP (Hypertext Transfer Protocol) este unul dintre cele mai utilizate protocoale de comunicare în arhitectura client-server, în special pentru aplicațiile web. HTTP definește cum trebuie să fie formatate cererile (requests) și răspunsurile (responses) între client și server.

O cerere HTTP tipică include:

• Metoda de cerere (GET, POST, PUT, DELETE etc.), care indică acțiunea dorită de client.
• URI (Uniform Resource Identifier), care specifică resursa solicitată.
• Header-uri care conțin informații adiționale despre cerere sau client.
• Corpul cererii (body), folosit pentru a trimite date, de exemplu, în cererile POST.

Răspunsul HTTP include:

• Cod de status (ex. 200 pentru succes, 404 pentru resursă negăsită).
• Header-uri cu informații despre răspuns sau server.
• Corpul răspunsului, care conține datele returnate clientului (ex. un fișier HTML sau JSON).

Mecanismul de bază în arhitectura client-server este Request-response cycle.

• Clientul inițiază o cerere către server, specificând ce resurse sau acțiuni sunt necesare.
• Serverul prelucrează cererea și răspunde clientului cu datele solicitate sau cu un mesaj de eroare, dacă cererea nu poate fi îndeplinită.

Acest proces permite interacțiunea continuă între client și server, fiecare cerere fiind procesată independent.

Un endpoint este o adresă URL la care serverul răspunde. În Flask:

@app.route('/tasks', methods=['GET'])
def get_tasks():
    # Logica pentru a returna toate task-urile
    return jsonify(tasks)

• GET: Citește/Returnează/Afișează/Obține date (ex: obține lista de task-uri)
• POST: Creează/Postează date noi (ex: adaugă un task nou)
• PUT: Actualizează (Pune chestii noi peste) date existente (ex: marchează task ca finalizat)
• DELETE: Șterge date (ex: șterge un task)

Datele sunt trimise între client și server în format JSON (document):

{
  "id": 1,
  "title": "Învață Flask",
  "completed": false
}

• 200 OK: Cererea a fost procesată cu succes
• 201 Created: Resursă nouă creată cu succes
• 400 Bad Request: Date invalide trimise de client
• 404 Not Found: Resursa nu există
• 500 Internal Server Error: Eroare pe server

1. Pentru a începe, asigurați-vă că aveți instalat Python.

Nu aveți Python? > python.org/downloads (bifați “Add to PATH” la instalare!)

2. Verificați instalarea rulând comanda în terminal: python –version.

3. Descarcati scheletul de cod de aici.

git clone https://github.com/ACS-ISI/Backend_Server
cd Backend_Server

Nu aveți git? > Descărcați ZIP de pe GitHub > Extract

Salvați fișierul după fiecare modificare. Serverul se restartează automat (debug mode).

4. Deschideti proiectul folosind IDE-ul preferat, de exemplu Visual Studio Code cu extensia Python sau un IDE specializat pentru Python, precum PyCharm și rulați comanda pentru instalarea dependențelor din fișierul requirements.txt.

5. Dupa finalizarea primului TO DO pentru testare descarcati postman de aici.

{
  "completed": true
}

{
  "id": 1,
  "title": "Finalizează laboratorul",
  "description": "Task 1 și Task 2",
  "completed": true
}

@app.route('/login', methods=['GET'])
def login():
    username = request.args.get('username')
    print(username)
    password = request.args.get('password')
    print(password)
    return jsonify({"status": True})

Completati TO DO-urile din scheletul de cod, acestea sunt self explanatory. Scopul acestora este sa intelegeti cum sa interactionati cu o baza de date prin intermediul unui server. Prin aceste metode numite endpoint-uri puteti realiza comunicarea dintre client si server.

Testati fiecare endpoint in parte, verificati ca functioneaza corect. Mai jos este descris un test case pe care sa-l abordati, iar de la acesta puteti sa realiza propriile voastre test case-uri.

Test Case: am adaugat 3 task-uri folosind endpoint-ul de adaugat task-uri, iar cand apelez endpoint-ul prin care obtin o lista cu task-uri acesta returneaza cele 3 task-uri adaugate anterior.

Verificați funcționarea aplicației folosind următoarele metode:

Instalați DB Browser for SQLite (versiunea portabilă). Acesta vă permite să accesați o bază de date SQLite folosind un editor vizual. Verificați conținutul bazei de date: deschideți din editor fișierul tasks.db din folder-ul instance

Rulați aplicația client din folder-ul frontend prin deschiderea fișierului index.html cu un browser. Verificați funcționarea sistemului integrat client-server. Examinați codul aplicației, identificați modul în care se transmit cererile HTTP și cum se realizează interfața cu utilizatorul.

Eroare: “ModuleNotFoundError: No module named 'flask'” Soluție: Nu ai instalat dependențele. Rulează:

pip install -r requirements.txt

Eroare: “Address already in use” Soluție: Portul 5000 este deja folosit. Oprește procesul anterior sau schimbă portul:

app.run(debug=True, port=5001)

Eroare: “404 Not Found” când testezi în Postman

Verificări:

• Serverul Flask rulează? (vezi în terminal)
• URL-ul este corect? (ex: `http://localhost:5000/tasks`)
• Metoda HTTP este corectă? (GET, POST, etc.)

Date nu apar în baza de date

Verificări:

• Ai apelat `db.session.commit()`?
• Nu sunt erori în consolă?
• Verifică cu DB Browser dacă fișierul `tasks.db` există în folder-ul `instance`

În laboratorul anterior ați folosit Firebase Realtime Database - o soluție “Backend as a Service” (BaaS) care oferă:

• Configurare rapidă (fără cod backend)
• Sincronizare în timp real automată
• Infrastructură gestionată de Google

Firebase este excelent pentru: prototipuri rapide, aplicații simple, MVP-uri, aplicații care necesită sincronizare în timp real out-of-the-box.

În practică, majoritatea aplicațiilor profesionale necesită un backend propriu din următoarele motive:

• Control Complet asupra Logicii de Business. Cu Firebase: logică complexă = cod client (expus și lent). Cu Flask: logică pe server (sigur și rapid)
• Securitate și Validare
• Flexibilitate la Baze de Date. La Firebase: structură JSON, limitări la query-uri complexe, în timp ce la Flask + SQLAlchemy: orice bază de date (SQLite, PostgreSQL, MySQL, MongoDB), query-uri SQL complete, relații complexe
• Integrări cu Servicii Externe
• Costuri și Scalabilitate. La Firebase: costurile cresc cu numărul de citiri/scrieri și trafic. Când avem backend propriu: control total asupra infrastructurii și optimizări

Comparație

Folosește Firebase când:

• Construiești un MVP/prototip rapid
• Aplicația este simplă (CRUD basic)
• Vrei sincronizare în timp real fără efort
• Echipa este mică și nu are expertiză backend

Folosește Flask (sau alt framework) când:

• Construiești o aplicație pentru producție
• Ai nevoie de logică complexă
• Securitatea este critică
• Vrei control total asupra datelor
• Planifici să scalezi aplicația
• Vrei să înveți cum funcționează cu adevărat un backend

• [Flask Official Docs](https://flask.palletsprojects.com/)
• [Flask-SQLAlchemy Quickstart](https://flask-sqlalchemy.readthedocs.io/en/stable/quickstart/)
• [HTTP Status Codes](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status)
• [REST API Best Practices](https://restfulapi.net/)

• [Flask Tutorial for Beginners](https://www.youtube.com/watch?v=Z1RJmh_OqeA)
• [Building a REST API with Flask](https://www.youtube.com/watch?v=s_ht4AKnWZg)

• [Flask Cheat Sheet](https://s3.us-east-2.amazonaws.com/prettyprinted/flask_cheatsheet.pdf)
• [SQLAlchemy Cheat Sheet](https://www.pythonsheets.com/notes/python-sqlalchemy.html)