Angular has support for receiving and sending objects via HTTP but we are not obliged to use it, we can retrieve objects with any library, see Dynamic Data.

Although one would hope that Angular has special arrangements for changing a database in the cloud directly from [(ngModel)] , this is not the case. Angular offers support for remote API access but that functionality is not coupled with the HTML generation functionality but mostly to data communication concerns: caching, progress report, etc.

The concept of Observable comes in handy, because one can build an Observable from just about anything, including

Promises: emit when the promise fulfils or is rejected
DOM events
timers

etc.

What is even more interesting for remote data access, if the emitted value is an error, Observables can retry for a specified amount of times. This is a HTTP GET for a hypotetical (for now) Shape API

import { HttpClient, HttpHeaders } from '@angular/common/http';
import { Observable } from 'rxjs/Observable';
import { catchError, retry } from 'rxjs/operators';
...

const httpOptions = {
 headers: new HttpHeaders({
 'Content-Type': 'application/json',
 'Authorization': 'my-auth-token'
 })
};
...
export class RemoteShapeService {
   constructor(private http: HttpClient){}
   getShape (sh: Shape): Observable<Shape>  {
      this.http.get<Shape>(this.ShapeAPIUrl, httpOptions)
         .pipe( 
              retry(3), // retry a failed request up to 3 times 
              catchError(e=>console.error(e)) // then handle the error 
              );
   }
...
}

pipe() is an Observable method that accepts a few operators: retry, catchError, etc.

As mentioned in TypeScript differences from Javascript, http.get() can be marked with a generic type notation <> that it will return JSON compatible to a <Shape>. Like all http operations, the result of getShape() is an Observable parametrized with Shape, i.e. Observable<Shape>, that is to say, an Observable that will emit Shapes. If you think that is too much hassle to write correctly, you do not have to specify the getShape() return result, TypeScript will detect it anyway.

Sometimes the result of a GET is not JSON and cannot be converted to an object of a given type. In that case we can still use the Angular HTTP support to retrieve it as text.

Most HTTP observables emit only once: when the HTTP operation has completed. They are termed "one and done" Observables.

A HTTP POST operation looks just as brief. It will return an Observable of the object inserted.

addShape (shape: Shape): Observable<Shape>  { 
      return this.http.post<Shape>(this.ShapeAPIUrl, shape, httpOptions)
             .pipe( 
                catchError(console.error); 
              );
}

Resources

https://angular.io/guide/http offers many more features such as caching, progress report events (e.g. for long HTTP uploads, etc)

https://angular.io/guide/http#rxjs

An example implementation of CRUD operations

https://medium.com/codingthesmartway-com-blog/angular-4-3-httpclient-accessing-rest-web-services-with-angular-2305b8fd654b