Se seu arquivo for nomeado `main.py`, execute sua aplicação com:

<div class="termy">

```console
$ fastapi dev main.py

<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```

</div>

Abra seu navegador em: <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000</a>.

Você verá uma página simples como:

    @Override
    public final T call() {
      try {
        return realCall();
      } catch (Throwable t) {
        threadUnexpectedException(t);
        return null;
      }
    }
  }

  public abstract class CheckedInterruptedCallable<T> implements Callable<T> {
    protected abstract T realCall() throws Throwable;

    @Override
    public final T call() {
      try {

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.curl.logging

import java.util.logging.ConsoleHandler
import java.util.logging.Level
import java.util.logging.LogManager
import java.util.logging.LogRecord
import java.util.logging.Logger
import okhttp3.internal.http2.Http2

            }
        }
    }

    @Test
    void testExtendedPluginDescriptor() {
        ExtendedPluginDescriptor.Builder builder = new ExtendedPluginDescriptor.Builder();
        // make sure to call the subclasses' builder methods first, otherwise fluent API would not work
        builder.additionalField("additional")
                .groupId("org.apache.maven")
                .artifactId("maven-plugin-api")

     * and bytes. This is so we can write batched smbs because
     * all but the first smb of the chaain do not have a header
     * and therefore we do not want to writeHeaderWireFormat. We
     * just recursivly call writeAndXWireFormat.
     */

    @Override
    public int encode(final byte[] dst, int dstIndex) {
        final int start = this.headerStart = dstIndex;

     *
     * @param dataset the dataset to do the calculation on, which must be non-empty, which will be
     *     cast to doubles (with any associated lost of precision), and which will not be mutated by
     *     this call (it is copied instead)
     * @return the quantile value
     */
    public double compute(Collection<? extends Number> dataset) {
      return computeInPlace(Doubles.toArray(dataset));
    }

    /**

    }

  fun wrap(eventRecorder: EventRecorder) = wrap(eventRecorder.eventListener)

  fun wrap(eventListenerFactory: EventListener.Factory) =
    EventListener.Factory { call ->
      ClientRuleEventListener(::addEvent) + eventListenerFactory.create(call)
    }

  /**
   * Returns an OkHttpClient for tests to use as a starting point.
   *

    private final Callable<T> delegate;

    WrappedCallable(Callable<T> delegate) {
      this.delegate = delegate;
    }

    @Override
    public T call() throws Exception {
      return delegate.call();
    }
  }

  private static final class WrappedRunnable implements Runnable {
    private final Runnable delegate;

    WrappedRunnable(Runnable delegate) {

    /** Suppresses the assertion on {@link TypeToken#getSupertype}. */
    boolean suppressGetSupertype() default false;
  }

  private @Nullable Method method = null;

  /** Call this in a {@link TestSubtype} public method asserting subtype relationship. */
  final <T> T isSubtype(T sub) {
    Type returnType = method.getGenericReturnType();
    Type paramType = getOnlyParameterType();

<div class="termy">

```console
$ fastapi run --forwarded-allow-ips="*"

<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```

</div>

### Redirecionamentos com HTTPS { #redirects-with-https }

Por exemplo, suponha que você defina uma *operação de rota* `/items/`: